diff --git a/research/h25-authentic-serializer-20261031/EVIDENCE-EXPORT-v2.json b/research/h25-authentic-serializer-20261031/EVIDENCE-EXPORT-v2.json new file mode 100644 index 0000000000..a86af5cbe6 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/EVIDENCE-EXPORT-v2.json @@ -0,0 +1,801 @@ +{ + "additional_copied_files": [ + { + "bytes": 25423, + "export_mode_octal": "0o444", + "git_blob_sha1": "d06541be6333abf793c08e09a9d17e0935194f6d", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/ADMISSION-TEMPLATE-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/ADMISSION-TEMPLATE-v2.json", + "sha256": "a42c3e6ade467b142647e2e3aac2ce53e67de1ba2309fcc15ec9a8d98c440f88" + }, + { + "bytes": 8733, + "export_mode_octal": "0o444", + "git_blob_sha1": "4074522ce333dcddc862779f43182b9a002f9918", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/ELF-CLOSURE-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/ELF-CLOSURE-v2.json", + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6" + }, + { + "bytes": 5379, + "export_mode_octal": "0o444", + "git_blob_sha1": "adb28bd936d2bb0fd48dc423428b612fac932f9d", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/FIXED-SEQUENCE-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/FIXED-SEQUENCE-v2.json", + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf" + }, + { + "bytes": 4762, + "export_mode_octal": "0o444", + "git_blob_sha1": "0fa6334221d8a91b02e3f389ed5cb80e7f934582", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/OPERATION-BILL-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/OPERATION-BILL-v2.json", + "sha256": "49f9ae04f02cf01f709cda31628a4223aebe206e0778ab0e91eee176ceed96a1" + }, + { + "bytes": 2440, + "export_mode_octal": "0o444", + "git_blob_sha1": "87be6e4c712ed752c88710e6b1badfb3aa49719d", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/PASSIVE-CHECKS-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/PASSIVE-CHECKS-v2.json", + "sha256": "b7bb642363b16034690ebbc16f6546d4e15e3cac038c4698e743d5427c52f6e0" + }, + { + "bytes": 9784, + "export_mode_octal": "0o444", + "git_blob_sha1": "d93c4fa4e02fb8b947b61d0f98bd646f1c0aca04", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/README-v2.md", + "package_path": "validation/envelope-revision-v2/envelope/README-v2.md", + "sha256": "46818370bf55026df7b05b2eb439a77d6ce5dba3d74fa97844a651a51a2a9a93" + }, + { + "bytes": 28663, + "export_mode_octal": "0o444", + "git_blob_sha1": "ec9a61f432810e7f0cf59be991330d41410212ba", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.json", + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea" + }, + { + "bytes": 65, + "export_mode_octal": "0o444", + "git_blob_sha1": "fa02fd12e1a5d65b5dad7f63d677dbe12f4ca128", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.sha256", + "package_path": "validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.sha256", + "sha256": "3bdd33b13783a402ecd4b3d48fbba117b7b72275317d3b23537ca972e4909d8e" + }, + { + "bytes": 854, + "export_mode_octal": "0o444", + "git_blob_sha1": "84eccbc72c47294b767e1f45d1bbe48d8fd3a35f", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/SOURCE-REPAIR-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/SOURCE-REPAIR-v2.json", + "sha256": "35bc801f6fb32857ad8e3c5ccd9eea2d0540f8aa470f0d8d8e194a1522f2f589" + }, + { + "bytes": 8248, + "export_mode_octal": "0o444", + "git_blob_sha1": "7b3e4275cef6e136cbef9a2a4f77164e78235511", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py", + "package_path": "validation/envelope-revision-v2/envelope/bootstrap.py", + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2" + }, + { + "bytes": 4943, + "export_mode_octal": "0o444", + "git_blob_sha1": "c7aaad3522550914cb3ea865d12a364ade30e874", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py", + "package_path": "validation/envelope-revision-v2/envelope/custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87" + }, + { + "bytes": 4274, + "export_mode_octal": "0o444", + "git_blob_sha1": "22b85b723dcf1da6913f2c8967948c1a22f4a63b", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py", + "package_path": "validation/envelope-revision-v2/envelope/effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830" + }, + { + "bytes": 797, + "export_mode_octal": "0o444", + "git_blob_sha1": "0e09204abcf9ce974886f8a5bcee428651a398c4", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py", + "package_path": "validation/envelope-revision-v2/envelope/loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f" + }, + { + "bytes": 15188, + "export_mode_octal": "0o444", + "git_blob_sha1": "46fe7cda255cd116fb7b9cd68dcb52f93ad23879", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py", + "package_path": "validation/envelope-revision-v2/envelope/observer.py", + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6" + }, + { + "bytes": 3757, + "export_mode_octal": "0o444", + "git_blob_sha1": "c7284fe90a5617ab736771dd8698ac4d4590ff8c", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py", + "package_path": "validation/envelope-revision-v2/envelope/observer_controls.py", + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd" + }, + { + "bytes": 2125, + "export_mode_octal": "0o444", + "git_blob_sha1": "8f1715e979004f5b0671eea96daa1b4c047695cd", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py", + "package_path": "validation/envelope-revision-v2/envelope/observer_fixture.py", + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788" + }, + { + "bytes": 3894, + "export_mode_octal": "0o444", + "git_blob_sha1": "9afd005ec9fe174e799e797dfb5ad7ee859e1690", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py", + "package_path": "validation/envelope-revision-v2/envelope/parent_readback.py", + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf" + }, + { + "bytes": 4772, + "export_mode_octal": "0o444", + "git_blob_sha1": "bb92d5bdba900afcb2899d1306dafba3f0706dc0", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py", + "package_path": "validation/envelope-revision-v2/envelope/sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557" + }, + { + "bytes": 6912, + "export_mode_octal": "0o444", + "git_blob_sha1": "35edac21bdf881fbaa86bb2ceea4cbca2fc6967b", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py", + "package_path": "validation/envelope-revision-v2/envelope/worker.py", + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487" + }, + { + "bytes": 4125, + "export_mode_octal": "0o444", + "git_blob_sha1": "9a20e9ace018fc9066a672dbed13ffdd02c52058", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/SOURCE-READINESS-v2.json", + "package_path": "validation/envelope-revision-v2/envelope/SOURCE-READINESS-v2.json", + "sha256": "c1e8bc8bff2fce24e9c9000ca53cc258d72fc0c8929bc558d02069de7e220fc2" + }, + { + "bytes": 18528, + "export_mode_octal": "0o444", + "git_blob_sha1": "8a9e3d4dfc88d76fe6e479ebcacddcc5539c1f77", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/ADMISSION-TEMPLATE-v1.json", + "package_path": "validation/rejected-envelope-v1/ADMISSION-TEMPLATE-v1.json", + "sha256": "30cb1f9d8ba4fb886a43793bf783f3fcdf69fa98cc658ee42eaacb26424825fe" + }, + { + "bytes": 4529, + "export_mode_octal": "0o444", + "git_blob_sha1": "41ccc68d6cb42a5b946849a60d8eef504fe35cb9", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/FIXED-SEQUENCE-v1.json", + "package_path": "validation/rejected-envelope-v1/FIXED-SEQUENCE-v1.json", + "sha256": "e156d8b8600d45b13646f24e46e8e6a3ac05b554c2df81d464447944c0e0095c" + }, + { + "bytes": 3577, + "export_mode_octal": "0o444", + "git_blob_sha1": "d8b08d5d6f20e5b2da6388e1938eab9b47684971", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/OPERATION-BILL-v1.json", + "package_path": "validation/rejected-envelope-v1/OPERATION-BILL-v1.json", + "sha256": "e7b0e21fdc01dc350ca5f71eb84757ae37161b527ea8eef82b14c63d9c79f97c" + }, + { + "bytes": 1909, + "export_mode_octal": "0o444", + "git_blob_sha1": "5b599edec19eff0e15aa09c7ba4323c905c38539", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/PASSIVE-CHECKS-v1.json", + "package_path": "validation/rejected-envelope-v1/PASSIVE-CHECKS-v1.json", + "sha256": "e8a7c60e568ef9ea57b9ae612145d46dbd372aae9d053eedb4c034d2864a725e" + }, + { + "bytes": 7602, + "export_mode_octal": "0o444", + "git_blob_sha1": "79d96219d5496b6a3e055a828678620dc74d97f8", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/README-v1.md", + "package_path": "validation/rejected-envelope-v1/README-v1.md", + "sha256": "c5337759f784b15e5a45a937ce12e767aea23ed86b1e901efc79da0cbac06d84" + }, + { + "bytes": 27394, + "export_mode_octal": "0o444", + "git_blob_sha1": "aeafd6b9d7fda73d8e4755fdb990d0431078e839", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/RUNTIME-PINS-v1.json", + "package_path": "validation/rejected-envelope-v1/RUNTIME-PINS-v1.json", + "sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0" + }, + { + "bytes": 65, + "export_mode_octal": "0o444", + "git_blob_sha1": "6bdbafa68387ef34fcd11eef06a5cb29004fde3f", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/RUNTIME-PINS-v1.sha256", + "package_path": "validation/rejected-envelope-v1/RUNTIME-PINS-v1.sha256", + "sha256": "067af3eb524cc3ea7a8389bac3ff93e50e14159565521977d7bede26f055ef42" + }, + { + "bytes": 3504, + "export_mode_octal": "0o444", + "git_blob_sha1": "51004ecdf64f90fc0735f82808aa69053101990e", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/SOURCE-READINESS-v1.json", + "package_path": "validation/rejected-envelope-v1/SOURCE-READINESS-v1.json", + "sha256": "e3f4f6e68b0dd7d66b2b269a346b09cfb315154c5a833cb05ed6db74e17101a2" + }, + { + "bytes": 7884, + "export_mode_octal": "0o444", + "git_blob_sha1": "075fad92cdb121afc20621872026ec97f274d98a", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/bootstrap.py", + "package_path": "validation/rejected-envelope-v1/bootstrap.py", + "sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb" + }, + { + "bytes": 4943, + "export_mode_octal": "0o444", + "git_blob_sha1": "c7aaad3522550914cb3ea865d12a364ade30e874", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/custody.py", + "package_path": "validation/rejected-envelope-v1/custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87" + }, + { + "bytes": 4274, + "export_mode_octal": "0o444", + "git_blob_sha1": "22b85b723dcf1da6913f2c8967948c1a22f4a63b", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/effective.py", + "package_path": "validation/rejected-envelope-v1/effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830" + }, + { + "bytes": 797, + "export_mode_octal": "0o444", + "git_blob_sha1": "0e09204abcf9ce974886f8a5bcee428651a398c4", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/loader_controls.py", + "package_path": "validation/rejected-envelope-v1/loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f" + }, + { + "bytes": 14564, + "export_mode_octal": "0o444", + "git_blob_sha1": "fe3e9cfc05b1d28d3a1c1483198dfe0d64ce2a89", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/observer.py", + "package_path": "validation/rejected-envelope-v1/observer.py", + "sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4" + }, + { + "bytes": 3694, + "export_mode_octal": "0o444", + "git_blob_sha1": "655feb5eb5c39c02a65d31942bffe8ac18be01fd", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/observer_controls.py", + "package_path": "validation/rejected-envelope-v1/observer_controls.py", + "sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e" + }, + { + "bytes": 2038, + "export_mode_octal": "0o444", + "git_blob_sha1": "c2400182ddab1577e47d8adeb1805dd0629e9de9", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/observer_fixture.py", + "package_path": "validation/rejected-envelope-v1/observer_fixture.py", + "sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0" + }, + { + "bytes": 4772, + "export_mode_octal": "0o444", + "git_blob_sha1": "bb92d5bdba900afcb2899d1306dafba3f0706dc0", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/sequence_worker.py", + "package_path": "validation/rejected-envelope-v1/sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557" + }, + { + "bytes": 6828, + "export_mode_octal": "0o444", + "git_blob_sha1": "505a190e91891d919232295c9a1b5ee55e6d7224", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot/worker.py", + "package_path": "validation/rejected-envelope-v1/worker.py", + "sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1" + }, + { + "bytes": 4168, + "export_mode_octal": "0o444", + "git_blob_sha1": "37b1e7056e7b88d711f95f89471e736e04212dd4", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-REVIEW-v1.json", + "package_path": "validation/source-reviews/I3-REVIEW-v1.json", + "sha256": "33113ecfebd19c41caa370f6da3591d38febe51e97a62c0c11a310921d4c0ebd" + }, + { + "bytes": 16983, + "export_mode_octal": "0o444", + "git_blob_sha1": "a1dfc4fd1d08b458a1e10950266cffce92a514d3", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-EVIDENCE.json", + "package_path": "validation/source-reviews/I3-v1-EVIDENCE.json", + "sha256": "38b33d6b0f9d1fdcf94a88716db8d2ddcf343a5ec2446a271c6500d45ca2394f" + }, + { + "bytes": 1981, + "export_mode_octal": "0o444", + "git_blob_sha1": "1cc8dc1ea03e7b6cc13115a894bd7e8999c24525", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-REJECTION-SUPPLEMENT.json", + "package_path": "validation/source-reviews/I3-v1-REJECTION-SUPPLEMENT.json", + "sha256": "e5f22cfcea5e19a3547b7fbd9c8fcba5c9e004d71a662d6d97db7088250e8199" + }, + { + "bytes": 4587, + "export_mode_octal": "0o444", + "git_blob_sha1": "5a584f23465d9578451739dfe083d59d141021e9", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-SNAPSHOT-PINS.json", + "package_path": "validation/source-reviews/I3-v1-SNAPSHOT-PINS.json", + "sha256": "bae6543afe3da6294243bec071988590da2759905fa4bf4caee78685ffc34ef5" + }, + { + "bytes": 7558, + "export_mode_octal": "0o444", + "git_blob_sha1": "6257939348707dc7df5ab96bb32aa1bdb16d0796", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-REVIEW-v2.json", + "package_path": "validation/source-reviews/I3-REVIEW-v2.json", + "sha256": "48f7b45833b003bf2283ca3e6befbd12a511faab34810115b0d350150aa0c12f" + }, + { + "bytes": 11735, + "export_mode_octal": "0o444", + "git_blob_sha1": "b706256dac8b934b23207dbaa78affe8c0475701", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v2-EVIDENCE.json", + "package_path": "validation/source-reviews/I3-v2-EVIDENCE.json", + "sha256": "8a078e15b9b65b3e39c140f86dbce0b818b6a2f9179a8e49804eeb502033ed51" + }, + { + "bytes": 1025, + "export_mode_octal": "0o444", + "git_blob_sha1": "00099b55c2f69accc0381001e46a0c0d38becd44", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/COMBINED-SOURCE-REVIEW-v1.json", + "package_path": "validation/source-reviews/COMBINED-SOURCE-REVIEW-v1.json", + "sha256": "f73a19d43ee254b3fdafaaccfa3439ffdda87f84067213a8a39d5393668226d0" + }, + { + "bytes": 3368, + "export_mode_octal": "0o444", + "git_blob_sha1": "c5a04dc2207f4a3e48f0ec8578e7a9dc71496d5b", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/EXPORT-REVIEW-v1.json", + "package_path": "validation/source-publication/EXPORT-REVIEW-v1.json", + "sha256": "ccdfd212bd15fcbbf7092f1308088e500747f402e4a12cf188dc29426abd0949" + }, + { + "bytes": 15742, + "export_mode_octal": "0o444", + "git_blob_sha1": "7f25a771db71a176fcd3a1d4bd4b17263ddca299", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/EXPORT-EVIDENCE-v1.json", + "package_path": "validation/source-publication/EXPORT-EVIDENCE-v1.json", + "sha256": "1a5ef9e915dfc918142a648be2accd265c57746e497d995964263d10a5e8f8a4" + }, + { + "bytes": 1419, + "export_mode_octal": "0o444", + "git_blob_sha1": "accc77418ec146a5d82a00c9f5f9f5bd76ab1d58", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/SOURCE-REMOTE-REVIEW-v1.json", + "package_path": "validation/source-publication/SOURCE-REMOTE-REVIEW-v1.json", + "sha256": "5ca5a19b5b70703686386afd281024e64f6b396888207788247a885e51203595" + }, + { + "bytes": 16541, + "export_mode_octal": "0o444", + "git_blob_sha1": "52f475dbec649a58d5fdc46342d13c1be782d09b", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/SOURCE-REMOTE-EVIDENCE-v1.json", + "package_path": "validation/source-publication/SOURCE-REMOTE-EVIDENCE-v1.json", + "sha256": "cddbcb07d6edb29d11c8b167d76aa43f3522522a6c96e46e96ec62a71ec1376f" + }, + { + "bytes": 1509, + "export_mode_octal": "0o444", + "git_blob_sha1": "a6d51af7bcaebb0c6c6f6ce23281449794253b40", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/SOURCE-PR-REVIEW-v1.json", + "package_path": "validation/source-publication/SOURCE-PR-REVIEW-v1.json", + "sha256": "85070855f04019c112e186c388e7a673c5be01f6ef11ecb52d54891ae1228f2d" + }, + { + "bytes": 6852, + "export_mode_octal": "0o444", + "git_blob_sha1": "8a6105be2f6109c1a93032d16a09df832777e7bc", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/SOURCE-PR-EVIDENCE-v1.json", + "package_path": "validation/source-publication/SOURCE-PR-EVIDENCE-v1.json", + "sha256": "afc874457238b443001d847458e0d1c9ca6088de109fe942dc2c4f08aef9db34" + }, + { + "bytes": 15315, + "export_mode_octal": "0o444", + "git_blob_sha1": "b46ec9fa1867587851100232073a0d2db40bd16c", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/EXPORT-FREEZE-v1.json", + "package_path": "validation/source-publication/EXPORT-FREEZE-v1.json", + "sha256": "5db374e8e9f8b69e574b2b24c4f4f3b8135927fbc044f1a2e7d3722ed05976f6" + }, + { + "bytes": 10934, + "export_mode_octal": "0o444", + "git_blob_sha1": "aa5d7c33ecf8b1b3fc052237bf11281f568da275", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/TREE-ENTRIES-v1.json", + "package_path": "validation/source-publication/TREE-ENTRIES-v1.json", + "sha256": "d1dd1293ab73b997fcca153a5bc446a56753c75e307ef1898726dd2e20478ca1" + }, + { + "bytes": 1335, + "export_mode_octal": "0o444", + "git_blob_sha1": "3884b084b45b9e3e3bd1f91c6b05b4cd13f8da49", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/I4-PACKET-v1.json", + "package_path": "validation/execution-v1/control-proposal/I4-PACKET-v1.json", + "sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879" + }, + { + "bytes": 2540, + "export_mode_octal": "0o444", + "git_blob_sha1": "0072b2eecd891371ddce1b8dbe4f82febc24fc86", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json", + "package_path": "validation/execution-v1/control-proposal/COMMAND-v1.json", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + { + "bytes": 2909, + "export_mode_octal": "0o444", + "git_blob_sha1": "a3a2c9a9500c8a60373bcfb66842f80ae50eb788", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-COMMAND-v1.json", + "package_path": "validation/execution-v1/control-proposal/READBACK-COMMAND-v1.json", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + { + "bytes": 4139, + "export_mode_octal": "0o444", + "git_blob_sha1": "d8f75fa552f92ad11db5783f4e8ac7c4e59a53c7", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json", + "package_path": "validation/execution-v1/control-proposal/LEDGER-RECONCILIATION-v1.json", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + { + "bytes": 33047, + "export_mode_octal": "0o444", + "git_blob_sha1": "96d2d36b68131aa343563cee5c9907a3f6803066", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "package_path": "validation/execution-v1/control-proposal/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + { + "bytes": 1926, + "export_mode_octal": "0o444", + "git_blob_sha1": "a593a0500413502de09458a98b1822c8f827e64a", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json", + "package_path": "validation/envelope-revision-v2/package-provenance/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + { + "bytes": 1912, + "export_mode_octal": "0o444", + "git_blob_sha1": "95917d3e64c03553b74373eab107a2a89a79cc19", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json", + "package_path": "validation/envelope-revision-v2/package-provenance/canonical-MANIFEST.json", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + { + "bytes": 1335, + "export_mode_octal": "0o444", + "git_blob_sha1": "3884b084b45b9e3e3bd1f91c6b05b4cd13f8da49", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/I4-PACKET-v1.json", + "package_path": "validation/execution-v1/control/I4-PACKET-v1.json", + "sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879" + }, + { + "bytes": 33047, + "export_mode_octal": "0o444", + "git_blob_sha1": "96d2d36b68131aa343563cee5c9907a3f6803066", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "package_path": "validation/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + { + "bytes": 2540, + "export_mode_octal": "0o444", + "git_blob_sha1": "0072b2eecd891371ddce1b8dbe4f82febc24fc86", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json", + "package_path": "validation/execution-v1/control/COMMAND-v1.json", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + { + "bytes": 2909, + "export_mode_octal": "0o444", + "git_blob_sha1": "a3a2c9a9500c8a60373bcfb66842f80ae50eb788", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-COMMAND-v1.json", + "package_path": "validation/execution-v1/control/READBACK-COMMAND-v1.json", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + { + "bytes": 4139, + "export_mode_octal": "0o444", + "git_blob_sha1": "d8f75fa552f92ad11db5783f4e8ac7c4e59a53c7", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json", + "package_path": "validation/execution-v1/control/LEDGER-RECONCILIATION-v1.json", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + { + "bytes": 581, + "export_mode_octal": "0o444", + "git_blob_sha1": "8cc7a2aa1516f276b3106a768ee25b62f4986a50", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LAUNCH-v1.json", + "package_path": "validation/execution-v1/control/LAUNCH-v1.json", + "sha256": "92c8ee7129be80dd54ac8156a1b7a184344c53b44b845602f33cba6bfa03acf2" + }, + { + "bytes": 126, + "export_mode_octal": "0o444", + "git_blob_sha1": "c752d1fcbf29fae3f77b38cb23e46c207250aa92", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/EXEC-RESULT-v1.json", + "package_path": "validation/execution-v1/control/EXEC-RESULT-v1.json", + "sha256": "156917ce5281901a1a08ed1c98093e9c9fd361c28cf135863ffe27f4c0e0e01c" + }, + { + "bytes": 1583, + "export_mode_octal": "0o444", + "git_blob_sha1": "63f739f57c5bb0c3a415b8b97142a198def85792", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-EXEC-RESULT-v1.json", + "package_path": "validation/execution-v1/control/READBACK-EXEC-RESULT-v1.json", + "sha256": "f3e03d0875879b0dc3316bc1e5b34ea28be8d3c8600587320422c50e222e10cf" + }, + { + "bytes": 148, + "export_mode_octal": "0o444", + "git_blob_sha1": "a8b5f46650c82884912cab62e2be6e7c218bd80e", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json", + "package_path": "validation/execution-v1/control/outer-time.json", + "sha256": "a5435c2c21b838555a1c8201831cbab5ccef5c3dd0120972078c86d8a110fdfa" + }, + { + "bytes": 65, + "export_mode_octal": "0o444", + "git_blob_sha1": "5288e16aca99b9ecf313e9762279b0465734cd37", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-consumed", + "package_path": "validation/execution-v1/control/complete-fixed-o03-consumed", + "sha256": "2a928d004026b4f90440b2cc970c2a851726e23c413d0dac086384f07e931c4c" + }, + { + "bytes": 2406, + "export_mode_octal": "0o444", + "git_blob_sha1": "54727ec9aabf569c6a12a4db0853b0e27a54e71c", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-001.json", + "package_path": "validation/execution-v1/control/LEDGER-001.json", + "sha256": "589b607e096d4ef7a49b38501827f1f5b865d1263591dff8b96cded9c7d62126" + }, + { + "bytes": 1130, + "export_mode_octal": "0o444", + "git_blob_sha1": "6dc341d4bfe0190e31d97cc9a337f455e5271384", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/FAILURE-v1.json", + "package_path": "validation/execution-v1/control/FAILURE-v1.json", + "sha256": "6f5381223a2cf6fb68fda081ecb723688c9237127865d397284ca6f3c585fc2b" + }, + { + "bytes": 2046, + "export_mode_octal": "0o444", + "git_blob_sha1": "46b56f1b25ef47ff35c2099aa551c149aa38da2c", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json", + "package_path": "validation/execution-v1/complete-fixed-o03/observer-receipt.json", + "sha256": "5258f2c2132f3438497c41116300f52dca6409f021b73025928c84e0b4918652" + }, + { + "bytes": 5001, + "export_mode_octal": "0o444", + "git_blob_sha1": "5e9b7751e2f5a062f65e46064d9ba1b8ce6c14e2", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I4-REVIEW-v1.json", + "package_path": "validation/source-reviews/I4-REVIEW-v1.json", + "sha256": "2affb5c91dfe0d41e3b9392b115ff6a135eb1a69d10673b7671bff34d6dc32da" + }, + { + "bytes": 21898, + "export_mode_octal": "0o444", + "git_blob_sha1": "4ba1dae6d7f55c72363c2395ddabcff58bd89d43", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I4-EVIDENCE-v1.json", + "package_path": "validation/source-reviews/I4-EVIDENCE-v1.json", + "sha256": "f377928429089b17c15b282a59588d32c79fdcccafdd28c3a28c0feaf111e12b" + }, + { + "bytes": 3125, + "export_mode_octal": "0o444", + "git_blob_sha1": "531b2be331b128fdc33cc25c85103170c6f74519", + "git_mode": "100644", + "note": "Immutable generated pre-outcome skeleton snapshot preserved before final README update.", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/EVIDENCE-README-v2-before-run.md", + "package_path": "validation/preparation/EVIDENCE-README-v2-before-run.md", + "sha256": "a011c5dc4fa17b5e44f0631a5ed989929d3cdba3a7247328f4afa13cc32af043" + }, + { + "bytes": 8295, + "export_mode_octal": "0o444", + "git_blob_sha1": "0a73cb655963a01f6ca02a9873cf817b4e756e01", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/FAILURE-REVIEW-v1.json", + "package_path": "validation/source-reviews/FAILURE-REVIEW-v1.json", + "sha256": "5979a7939926bb01a3d2f9a44e59a502ab0d0415abf275f5d7331a5450aea5ea" + }, + { + "bytes": 4736, + "export_mode_octal": "0o444", + "git_blob_sha1": "567636a49722d0faf8d5ac1ffc7f6450b7ef486e", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/FAILURE-EVIDENCE-v1.json", + "package_path": "validation/source-reviews/FAILURE-EVIDENCE-v1.json", + "sha256": "ec4d513db9138a015e5ee74c78c983317cd4a48c55def64e2f55b87495bbad6c" + } + ], + "current_credit": { + "I1_I2": "ACCEPT_SOURCE_SCOPE", + "I3": "INVALIDATED_KNOWN_INCOMPLETE", + "I4": "CONSUMED_FAILED_CLOSED_NO_CURRENT_PASSED_CREDIT", + "I5_I6_I7_O03": "UNQUALIFIED_REJECTED_NO_EXECUTED_EVIDENCE", + "denominator": 8, + "failure_credit": 0, + "historical_high_water": 4, + "valid": 2 + }, + "first_complete_export": "validation/source-publication/EXPORT-FREEZE-v1.json;51 entries unchanged", + "first_source_map": "SOURCES-EXPORT-v1.json;46 historical copied source/proof/input artifacts, unchanged", + "generated_added_files": [ + "EVIDENCE-README-v2.md", + "PUBLIC-OUTCOME-v2.json", + "TAKEOVER-v2.md", + "validation/envelope-revision-v2/CURRENT-STATUS-v2.json", + "EVIDENCE-EXPORT-v2.json", + "PACKAGE-MANIFEST-v2.json" + ], + "historical_first_source_commit": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "relocation": "Byte-exact failed source/templates retain absolute host paths as historical evidence. No new clone-and-run/admission is supplied. New host/runtime/path/custody/ledger/source closure needs explicit new authorization and independent review.", + "schema": "h25-authentic-serializer-evidence-export-v2", + "source_edits_or_retry_after_failure": 0, + "status": "RETAINED_FIRST_FAILURE_NO_QUALIFYING_EXECUTION", + "tail": "OPEN_NOT_ZERO" +} diff --git a/research/h25-authentic-serializer-20261031/EVIDENCE-README-v2.md b/research/h25-authentic-serializer-20261031/EVIDENCE-README-v2.md new file mode 100644 index 0000000000..6a2d6541d9 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/EVIDENCE-README-v2.md @@ -0,0 +1,21 @@ +# First fixed operation stopped; retained evidence + +The parent executed the once-only independently admitted operation after I1/I2/I3 source acceptance and exact I4 admission. The first operation stopped during observer runtime authentication before worker dispatch. It reported `unsealed mapped files: ['/usr/lib/locale/locale-archive']` both before and after the attempted core. No observer/loader/consumer controls, target imports, authentic payload decoding, baseline/candidate replay or independent output validation was reached. The declared single parent closing readback then failed: its JSON parser rejected the preserved GNU time nonzero diagnostic prefix before writing a report. There is no successful parent-readback report. + +The exact raw outer-time.json retains its first line `Command exited with non-zero status 1` followed by the original JSON record. No raw record was repaired, normalized or substituted. The manual bounded accounting interpretation in LEDGER-001.json is explicitly separate from the failed declared readback. It reports0.33s outer wall,0.26s user CPU,0.06s system CPU and19392KiB individual kernel maxRSS, exit1. The parent conservatively charged0.34 policy seconds including0.01s rounding, taking the existing canonical total from94.210533479 to94.550533479 of2400. The observer STOP record reports24 samples and19726336 bytes sampled simultaneous discoverable-group RSS. These are failure-attempt observations with sampling/CPU/completion limitations, not serializer performance results, cap-feasibility proof, true continuous group peak or complete physical cost. + +Historical I3 source acceptance and I4 dispatch authorization remain unchanged records: dispatch was authorized and failed closed. After the observed missing locale map and failed closing readback, CURRENT I3 is INVALIDATED_KNOWN_INCOMPLETE; CURRENT I4 is CONSUMED_FAILED_CLOSED with no current passed credit. I1/I2 remain accepted:2/8 current valid checkpoints, historical high-water4. Failure-evidence acceptance adds0 checkpoint credit and resets no progress clock. + +The failure ended this implementation round's target execution. No retry, reroll, source repair or additional target execution followed. Actual control successes and full replays remain0; I5/I6/I7, O03 qualification and measured gain remain unachieved. A prospective gain/no-gain route is not a measured no-gain disposition. No universal serializer impossibility is inferred. Controller instrumentation, incomplete failed core accounting, final record/readback/reconciliation/review/publication and historical/global physical tails remain OPEN_NOT_ZERO. Full caller, other original goal obligations and denominators remain unchanged. + +Independent FAILURE-REVIEW-v1.json accepts retained failure attribution and scoped policy accounting, rejects O03 for lack of qualifying executed evidence, and adjudicates the current credit above. It authorizes no repair or execution. + +The review progression is preserved: exact rejected v1 envelope snapshot and rejection/supplement; one permitted source repair; independent I3-v2/combined complete source acceptance; exact I4 once-only admission; then the actual first failure and failed readback. Authored readiness/proposal records retain their historical pending labels; independent reviews and actual outcome records provide the subsequent disposition. Source-only feasibility under provenance/feasibility is a prerequisite basis, never runtime qualification. + +Root README.md, TASK.json, SOURCES.json, SOURCES-EXPORT-v1.json and PACKAGE-MANIFEST-v1.json retain their exact first-source-commit bytes and historical scope at bc88937088bdd9f4f71fbdc9246dbf58b11eb725. The original manifest describes its50 entries excluding itself; validation/source-publication/EXPORT-FREEZE-v1.json binds the original51 files. This later evidence record supersedes their pending-status narrative for the completed first attempt without changing their original meaning. A separate versioned complete final package manifest seals the later tree. The pre-outcome skeleton is retained under validation/preparation/. + +validation/execution-v1/control/ contains all12 exact named operation/admission/launch/tool-result/outer-time/consumed/ledger/failure records. validation/execution-v1/complete-fixed-o03/ contains only observer-receipt.json. No synthetic missing report or invented PASS is included. validation/source-reviews/ carries independent source/admission/failure dispositions; validation/envelope-revision-v2/ and validation/rejected-envelope-v1/ preserve accepted and rejected source identities. TAKEOVER-v2.md states remaining dependencies without authorizing more work. + +Absolute host paths, runtime/interpreter/native/shared-library/map metadata and exact command records are historical execution evidence. They are not portable clone-and-run instructions or a universal runtime seal. Any new host/path/runtime or repair requires a fresh reviewed closure, independently owned source/input custody, actual effective-provider binding, current canonical ledger/lock and new explicit parent execution authorization. Git100644 modes do not preserve0444/0555/inode/owner custody. The existing consumed admission cannot be reused. + +Publication proves only that exact source/failure evidence was delivered after its independent export review. Hosted planning success and skipped replay remain distinct. No O03, full-caller, original whole-goal, mathematical or kappa result follows. Prepared for Clear1nsight with substantial OpenAI Codex assistance using GPT-6.1-sol high authors/reviewers; original upstream and predecessor credit and repository Apache-2.0 license remain. diff --git a/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v1.json b/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v1.json new file mode 100644 index 0000000000..6889471d57 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v1.json @@ -0,0 +1,360 @@ +{ + "bytes_excluding_self": 17370493, + "copied_source_bytes_unchanged": true, + "execution_admitted": false, + "file_count_excluding_self": 50, + "files": { + "README.md": { + "bytes": 5174, + "git_blob_sha1": "9d107621005d53d443c9572c31b6df78656fe225", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "84f6927b46476b5c81c709ee3364904d7c07095f6a0e5a6c5bdf135bd10e85b8" + }, + "SOURCES-EXPORT-v1.json": { + "bytes": 23776, + "git_blob_sha1": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c92006685cd62c8e957c6b0521ae3f42258004991541ff8a317e63eabbbf4a5d" + }, + "SOURCES.json": { + "bytes": 1951, + "git_blob_sha1": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c9f4012e612935ecaf449859d898f357f15d14139051f55c980a56b8af37e0c6" + }, + "TASK.json": { + "bytes": 1715, + "git_blob_sha1": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "3e167e4b5659967df2f1034e051fa54b5f3253de4512cb83db4e78e4e49b31d3" + }, + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "git_blob_sha1": "cab48c3a31b095e78253899bff95548e44a32e6f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + "consumer/CONTROL-SPEC.json": { + "bytes": 3062, + "git_blob_sha1": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "consumer/DEPENDENCIES-v1.json": { + "bytes": 3934, + "git_blob_sha1": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + "consumer/PACKAGE-PINS-v1.json": { + "bytes": 2453, + "git_blob_sha1": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc" + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "git_blob_sha1": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "git_blob_sha1": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + "consumer/README-v1.md": { + "bytes": 6609, + "git_blob_sha1": "8879b820a9c05c78857964f0674ae4c4806a7726", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + "consumer/SOURCE-READINESS-v1.json": { + "bytes": 2081, + "git_blob_sha1": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + "consumer/bounded_serialization.py": { + "bytes": 23560, + "git_blob_sha1": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "consumer/full_consumer.py": { + "bytes": 9411, + "git_blob_sha1": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + "consumer/reference.py": { + "bytes": 2141, + "git_blob_sha1": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "consumer/run_controls.py": { + "bytes": 6630, + "git_blob_sha1": "1926eb081f24a953f1521ee63555fe7910a26e05", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + "consumer/serialization_controls.py": { + "bytes": 23684, + "git_blob_sha1": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "consumer/validate_outputs.py": { + "bytes": 14577, + "git_blob_sha1": "ade0aa6b46e28531797062f73b664efc8705f445", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + }, + "inputs/baseline/evidence/canonical/complex-network.json": { + "bytes": 5662, + "git_blob_sha1": "62a6091887a3894535c1d059e1b0c527d556eb76", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "inputs/baseline/evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "git_blob_sha1": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "inputs/baseline/evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "git_blob_sha1": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "loader/API-v1.md": { + "bytes": 5012, + "git_blob_sha1": "ec051bd35aad548258708278b146a037908a7dfa", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + "loader/CONTROL-SPEC-v1.json": { + "bytes": 2002, + "git_blob_sha1": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + "loader/PACKAGE-PINS-v1.json": { + "bytes": 1152, + "git_blob_sha1": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71" + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "git_blob_sha1": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + "loader/SOURCE-PINS-v1.json": { + "bytes": 2395, + "git_blob_sha1": "b584cb6cdee15071f76918e1055a224000c5f255", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + "loader/SOURCE-READINESS-v1.json": { + "bytes": 2306, + "git_blob_sha1": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + "loader/frozen_h25_inputs.py": { + "bytes": 14650, + "git_blob_sha1": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "loader/frozen_input_controls.py": { + "bytes": 13181, + "git_blob_sha1": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + }, + "provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json": { + "bytes": 2945, + "git_blob_sha1": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5b44b61996e11eae2d495fbdfbd20e221fac99937a44491dff3166af45466c6d" + }, + "provenance/feasibility/contract/DECISION-v1.json": { + "bytes": 9046, + "git_blob_sha1": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6d9bf443793f6ca6eaef574faa7935a52d8f510abcb0ae8371d59b608ba1a9c8" + }, + "provenance/feasibility/contract/O03-MATRIX-v1.json": { + "bytes": 18742, + "git_blob_sha1": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "99720019aaec5273e9da703e83c1795741a8d0fbba1b3d0e9b571dca2f4fe60c" + }, + "provenance/feasibility/review/REVIEW-v1.json": { + "bytes": 10656, + "git_blob_sha1": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "387ce2469788a5b93e35abb5472780d8421a065fd91b7ebcb1044cf8af0a9780" + }, + "provenance/feasibility/technical/FEASIBILITY-v1.json": { + "bytes": 11462, + "git_blob_sha1": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ce706af4d4092be6f23c69aa5d2dc66929442c182f18a34366f4ba8e5cf53f27" + }, + "provenance/feasibility/technical/PROBE-SPEC-v1.json": { + "bytes": 11830, + "git_blob_sha1": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a5885aea89261a3b1aa024e6771ed299845f4b587833a9e9e97b70802eefa2d7" + }, + "provenance/feasibility/technical/SOURCE-PINS-v1.json": { + "bytes": 12719, + "git_blob_sha1": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ad7fb8b6ac220879c6bdbb59d458d86067eabc60237378f2f396df80c1e0d9ae" + }, + "provenance/implementation/PLAN-v1.md": { + "bytes": 6135, + "git_blob_sha1": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234" + }, + "provenance/implementation/control/AUTHORIZATION-v1.json": { + "bytes": 1169, + "git_blob_sha1": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2" + }, + "provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json": { + "bytes": 3351, + "git_blob_sha1": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b39edf02587bb99c1464fab8d9bd9ea531a5bc6448eda92b95d841b4baa4fa54" + }, + "provenance/original-goal/control/PLAN-before-granular-progress-v1.md": { + "bytes": 14285, + "git_blob_sha1": "97b016c958d3e309ef884213fda3328388f69e58", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e" + }, + "provenance/original-goal/control/hourly-progress/RUBRIC-v1.json": { + "bytes": 6249, + "git_blob_sha1": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1" + }, + "provenance/original-serializer/ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "git_blob_sha1": "1767b5809d01af10dd64eb528b37f22049c53734", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "provenance/original-serializer/REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "git_blob_sha1": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "provenance/original-serializer/provenance/compare_side_verifier.py": { + "bytes": 10571, + "git_blob_sha1": "d94920c274c0a47db9763dd595230d52df0bd073", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "provenance/original-serializer/provenance/native_backend.py": { + "bytes": 20334, + "git_blob_sha1": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "provenance/original-serializer/provenance/profile_side_verifier.py": { + "bytes": 8959, + "git_blob_sha1": "807855eb875673c47da0ed1b5a890a417e28a846", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "reviews/I1-EVIDENCE-v1.json": { + "bytes": 2211, + "git_blob_sha1": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2e416ae27c6e79372e4b22d7c8ac212880e99f431504f278740e1dd2b6033aeb" + }, + "reviews/I1-REVIEW-v1.json": { + "bytes": 5166, + "git_blob_sha1": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ba00118a5c665beb5dbc12f22bf85f47c90d7bc676e4a98d3b901616cbafb115" + }, + "reviews/I2-EVIDENCE-v1.json": { + "bytes": 5912, + "git_blob_sha1": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "54567df4f843827537c9ce1a5e472f592afa6ac1462832dcad558e2f6a363c1d" + }, + "reviews/I2-REVIEW-v1.json": { + "bytes": 4600, + "git_blob_sha1": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ef8b3f12d33ce85277b90c9727545db0252c3104eb6e81444f0b82448c61881e" + } + }, + "schema": "h25-authentic-serializer-package-manifest-v1", + "self_excluded": "PACKAGE-MANIFEST-v1.json; full tree sealed by external EXPORT-FREEZE-v1.json" +} diff --git a/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v2.json b/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v2.json new file mode 100644 index 0000000000..371a46df53 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v2.json @@ -0,0 +1,942 @@ +{ + "bytes_excluding_self": 17963933, + "current_outcome": "RETAINED_FIRST_FAILURE;0 controls/replay;I3 known incomplete,I4 consumed failed;no O03/gain", + "file_count_excluding_self": 133, + "files": { + "EVIDENCE-EXPORT-v2.json": { + "bytes": 42218, + "git_blob_sha1": "a86af5cbe6c763d0091628f7dc87aed1fc600540", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ad1af87c2ff1f1b126718bb349f721f4ce4a1a3210bb94ce86c34faf54947150" + }, + "EVIDENCE-README-v2.md": { + "bytes": 5675, + "git_blob_sha1": "6a2d6541d92c25be3120d22d7db00e37d276c0ec", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "d30ec1f7c46fa57565bbd1af84cc2bb8fa6d351964e8215d61f8af1e2387d4fb" + }, + "PACKAGE-MANIFEST-v1.json": { + "bytes": 14454, + "git_blob_sha1": "6889471d578aa766d0929510cbf9aa5ae2f8157c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f170e1b7e8c0e7dde8544823be361e83e46b24a1e7f5b99cd9864b71e8017122" + }, + "PUBLIC-OUTCOME-v2.json": { + "bytes": 2552, + "git_blob_sha1": "8abe5981cd3357a460973dc00ac2a954261ce650", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ab4cb5866d7d87bd45deb48887a680cd199297f36273ed787302605c62a6d32f" + }, + "README.md": { + "bytes": 5174, + "git_blob_sha1": "9d107621005d53d443c9572c31b6df78656fe225", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "84f6927b46476b5c81c709ee3364904d7c07095f6a0e5a6c5bdf135bd10e85b8" + }, + "SOURCES-EXPORT-v1.json": { + "bytes": 23776, + "git_blob_sha1": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c92006685cd62c8e957c6b0521ae3f42258004991541ff8a317e63eabbbf4a5d" + }, + "SOURCES.json": { + "bytes": 1951, + "git_blob_sha1": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c9f4012e612935ecaf449859d898f357f15d14139051f55c980a56b8af37e0c6" + }, + "TAKEOVER-v2.md": { + "bytes": 2773, + "git_blob_sha1": "a54ec5028632a1ba64c4e9b7ab3c62623667ee9c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "d6578c1f81b4f4691c5131878874b41c8ee78256be3f40df05ebeb93cd367ff2" + }, + "TASK.json": { + "bytes": 1715, + "git_blob_sha1": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "3e167e4b5659967df2f1034e051fa54b5f3253de4512cb83db4e78e4e49b31d3" + }, + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "git_blob_sha1": "cab48c3a31b095e78253899bff95548e44a32e6f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + "consumer/CONTROL-SPEC.json": { + "bytes": 3062, + "git_blob_sha1": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "consumer/DEPENDENCIES-v1.json": { + "bytes": 3934, + "git_blob_sha1": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + "consumer/PACKAGE-PINS-v1.json": { + "bytes": 2453, + "git_blob_sha1": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc" + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "git_blob_sha1": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "git_blob_sha1": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + "consumer/README-v1.md": { + "bytes": 6609, + "git_blob_sha1": "8879b820a9c05c78857964f0674ae4c4806a7726", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + "consumer/SOURCE-READINESS-v1.json": { + "bytes": 2081, + "git_blob_sha1": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + "consumer/bounded_serialization.py": { + "bytes": 23560, + "git_blob_sha1": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "consumer/full_consumer.py": { + "bytes": 9411, + "git_blob_sha1": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + "consumer/reference.py": { + "bytes": 2141, + "git_blob_sha1": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "consumer/run_controls.py": { + "bytes": 6630, + "git_blob_sha1": "1926eb081f24a953f1521ee63555fe7910a26e05", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + "consumer/serialization_controls.py": { + "bytes": 23684, + "git_blob_sha1": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "consumer/validate_outputs.py": { + "bytes": 14577, + "git_blob_sha1": "ade0aa6b46e28531797062f73b664efc8705f445", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + }, + "inputs/baseline/evidence/canonical/complex-network.json": { + "bytes": 5662, + "git_blob_sha1": "62a6091887a3894535c1d059e1b0c527d556eb76", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "inputs/baseline/evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "git_blob_sha1": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "inputs/baseline/evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "git_blob_sha1": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "loader/API-v1.md": { + "bytes": 5012, + "git_blob_sha1": "ec051bd35aad548258708278b146a037908a7dfa", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + "loader/CONTROL-SPEC-v1.json": { + "bytes": 2002, + "git_blob_sha1": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + "loader/PACKAGE-PINS-v1.json": { + "bytes": 1152, + "git_blob_sha1": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71" + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "git_blob_sha1": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + "loader/SOURCE-PINS-v1.json": { + "bytes": 2395, + "git_blob_sha1": "b584cb6cdee15071f76918e1055a224000c5f255", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + "loader/SOURCE-READINESS-v1.json": { + "bytes": 2306, + "git_blob_sha1": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + "loader/frozen_h25_inputs.py": { + "bytes": 14650, + "git_blob_sha1": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "loader/frozen_input_controls.py": { + "bytes": 13181, + "git_blob_sha1": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + }, + "provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json": { + "bytes": 2945, + "git_blob_sha1": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5b44b61996e11eae2d495fbdfbd20e221fac99937a44491dff3166af45466c6d" + }, + "provenance/feasibility/contract/DECISION-v1.json": { + "bytes": 9046, + "git_blob_sha1": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6d9bf443793f6ca6eaef574faa7935a52d8f510abcb0ae8371d59b608ba1a9c8" + }, + "provenance/feasibility/contract/O03-MATRIX-v1.json": { + "bytes": 18742, + "git_blob_sha1": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "99720019aaec5273e9da703e83c1795741a8d0fbba1b3d0e9b571dca2f4fe60c" + }, + "provenance/feasibility/review/REVIEW-v1.json": { + "bytes": 10656, + "git_blob_sha1": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "387ce2469788a5b93e35abb5472780d8421a065fd91b7ebcb1044cf8af0a9780" + }, + "provenance/feasibility/technical/FEASIBILITY-v1.json": { + "bytes": 11462, + "git_blob_sha1": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ce706af4d4092be6f23c69aa5d2dc66929442c182f18a34366f4ba8e5cf53f27" + }, + "provenance/feasibility/technical/PROBE-SPEC-v1.json": { + "bytes": 11830, + "git_blob_sha1": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a5885aea89261a3b1aa024e6771ed299845f4b587833a9e9e97b70802eefa2d7" + }, + "provenance/feasibility/technical/SOURCE-PINS-v1.json": { + "bytes": 12719, + "git_blob_sha1": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ad7fb8b6ac220879c6bdbb59d458d86067eabc60237378f2f396df80c1e0d9ae" + }, + "provenance/implementation/PLAN-v1.md": { + "bytes": 6135, + "git_blob_sha1": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234" + }, + "provenance/implementation/control/AUTHORIZATION-v1.json": { + "bytes": 1169, + "git_blob_sha1": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2" + }, + "provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json": { + "bytes": 3351, + "git_blob_sha1": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b39edf02587bb99c1464fab8d9bd9ea531a5bc6448eda92b95d841b4baa4fa54" + }, + "provenance/original-goal/control/PLAN-before-granular-progress-v1.md": { + "bytes": 14285, + "git_blob_sha1": "97b016c958d3e309ef884213fda3328388f69e58", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e" + }, + "provenance/original-goal/control/hourly-progress/RUBRIC-v1.json": { + "bytes": 6249, + "git_blob_sha1": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1" + }, + "provenance/original-serializer/ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "git_blob_sha1": "1767b5809d01af10dd64eb528b37f22049c53734", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "provenance/original-serializer/REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "git_blob_sha1": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "provenance/original-serializer/provenance/compare_side_verifier.py": { + "bytes": 10571, + "git_blob_sha1": "d94920c274c0a47db9763dd595230d52df0bd073", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "provenance/original-serializer/provenance/native_backend.py": { + "bytes": 20334, + "git_blob_sha1": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "provenance/original-serializer/provenance/profile_side_verifier.py": { + "bytes": 8959, + "git_blob_sha1": "807855eb875673c47da0ed1b5a890a417e28a846", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "reviews/I1-EVIDENCE-v1.json": { + "bytes": 2211, + "git_blob_sha1": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2e416ae27c6e79372e4b22d7c8ac212880e99f431504f278740e1dd2b6033aeb" + }, + "reviews/I1-REVIEW-v1.json": { + "bytes": 5166, + "git_blob_sha1": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ba00118a5c665beb5dbc12f22bf85f47c90d7bc676e4a98d3b901616cbafb115" + }, + "reviews/I2-EVIDENCE-v1.json": { + "bytes": 5912, + "git_blob_sha1": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "54567df4f843827537c9ce1a5e472f592afa6ac1462832dcad558e2f6a363c1d" + }, + "reviews/I2-REVIEW-v1.json": { + "bytes": 4600, + "git_blob_sha1": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ef8b3f12d33ce85277b90c9727545db0252c3104eb6e81444f0b82448c61881e" + }, + "validation/envelope-revision-v2/CURRENT-STATUS-v2.json": { + "bytes": 1093, + "git_blob_sha1": "6c5ec2ca9d796af614eb5d33394b8c6ddfb8a759", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8445be5a74ded48d6ec8a7f4b59f3bdb4c1481fef20843c15aa4ab605a67569d" + }, + "validation/envelope-revision-v2/envelope/ADMISSION-TEMPLATE-v2.json": { + "bytes": 25423, + "git_blob_sha1": "d06541be6333abf793c08e09a9d17e0935194f6d", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a42c3e6ade467b142647e2e3aac2ce53e67de1ba2309fcc15ec9a8d98c440f88" + }, + "validation/envelope-revision-v2/envelope/ELF-CLOSURE-v2.json": { + "bytes": 8733, + "git_blob_sha1": "4074522ce333dcddc862779f43182b9a002f9918", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6" + }, + "validation/envelope-revision-v2/envelope/FIXED-SEQUENCE-v2.json": { + "bytes": 5379, + "git_blob_sha1": "adb28bd936d2bb0fd48dc423428b612fac932f9d", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf" + }, + "validation/envelope-revision-v2/envelope/OPERATION-BILL-v2.json": { + "bytes": 4762, + "git_blob_sha1": "0fa6334221d8a91b02e3f389ed5cb80e7f934582", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "49f9ae04f02cf01f709cda31628a4223aebe206e0778ab0e91eee176ceed96a1" + }, + "validation/envelope-revision-v2/envelope/PASSIVE-CHECKS-v2.json": { + "bytes": 2440, + "git_blob_sha1": "87be6e4c712ed752c88710e6b1badfb3aa49719d", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b7bb642363b16034690ebbc16f6546d4e15e3cac038c4698e743d5427c52f6e0" + }, + "validation/envelope-revision-v2/envelope/README-v2.md": { + "bytes": 9784, + "git_blob_sha1": "d93c4fa4e02fb8b947b61d0f98bd646f1c0aca04", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "46818370bf55026df7b05b2eb439a77d6ce5dba3d74fa97844a651a51a2a9a93" + }, + "validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.json": { + "bytes": 28663, + "git_blob_sha1": "ec9a61f432810e7f0cf59be991330d41410212ba", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea" + }, + "validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.sha256": { + "bytes": 65, + "git_blob_sha1": "fa02fd12e1a5d65b5dad7f63d677dbe12f4ca128", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "3bdd33b13783a402ecd4b3d48fbba117b7b72275317d3b23537ca972e4909d8e" + }, + "validation/envelope-revision-v2/envelope/SOURCE-READINESS-v2.json": { + "bytes": 4125, + "git_blob_sha1": "9a20e9ace018fc9066a672dbed13ffdd02c52058", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c1e8bc8bff2fce24e9c9000ca53cc258d72fc0c8929bc558d02069de7e220fc2" + }, + "validation/envelope-revision-v2/envelope/SOURCE-REPAIR-v2.json": { + "bytes": 854, + "git_blob_sha1": "84eccbc72c47294b767e1f45d1bbe48d8fd3a35f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "35bc801f6fb32857ad8e3c5ccd9eea2d0540f8aa470f0d8d8e194a1522f2f589" + }, + "validation/envelope-revision-v2/envelope/bootstrap.py": { + "bytes": 8248, + "git_blob_sha1": "7b3e4275cef6e136cbef9a2a4f77164e78235511", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2" + }, + "validation/envelope-revision-v2/envelope/custody.py": { + "bytes": 4943, + "git_blob_sha1": "c7aaad3522550914cb3ea865d12a364ade30e874", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87" + }, + "validation/envelope-revision-v2/envelope/effective.py": { + "bytes": 4274, + "git_blob_sha1": "22b85b723dcf1da6913f2c8967948c1a22f4a63b", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830" + }, + "validation/envelope-revision-v2/envelope/loader_controls.py": { + "bytes": 797, + "git_blob_sha1": "0e09204abcf9ce974886f8a5bcee428651a398c4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f" + }, + "validation/envelope-revision-v2/envelope/observer.py": { + "bytes": 15188, + "git_blob_sha1": "46fe7cda255cd116fb7b9cd68dcb52f93ad23879", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6" + }, + "validation/envelope-revision-v2/envelope/observer_controls.py": { + "bytes": 3757, + "git_blob_sha1": "c7284fe90a5617ab736771dd8698ac4d4590ff8c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd" + }, + "validation/envelope-revision-v2/envelope/observer_fixture.py": { + "bytes": 2125, + "git_blob_sha1": "8f1715e979004f5b0671eea96daa1b4c047695cd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788" + }, + "validation/envelope-revision-v2/envelope/parent_readback.py": { + "bytes": 3894, + "git_blob_sha1": "9afd005ec9fe174e799e797dfb5ad7ee859e1690", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf" + }, + "validation/envelope-revision-v2/envelope/sequence_worker.py": { + "bytes": 4772, + "git_blob_sha1": "bb92d5bdba900afcb2899d1306dafba3f0706dc0", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557" + }, + "validation/envelope-revision-v2/envelope/worker.py": { + "bytes": 6912, + "git_blob_sha1": "35edac21bdf881fbaa86bb2ceea4cbca2fc6967b", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487" + }, + "validation/envelope-revision-v2/package-provenance/anchor.json": { + "bytes": 1926, + "git_blob_sha1": "a593a0500413502de09458a98b1822c8f827e64a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "validation/envelope-revision-v2/package-provenance/canonical-MANIFEST.json": { + "bytes": 1912, + "git_blob_sha1": "95917d3e64c03553b74373eab107a2a89a79cc19", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "validation/execution-v1/complete-fixed-o03/observer-receipt.json": { + "bytes": 2046, + "git_blob_sha1": "46b56f1b25ef47ff35c2099aa551c149aa38da2c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5258f2c2132f3438497c41116300f52dca6409f021b73025928c84e0b4918652" + }, + "validation/execution-v1/control-proposal/COMMAND-v1.json": { + "bytes": 2540, + "git_blob_sha1": "0072b2eecd891371ddce1b8dbe4f82febc24fc86", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "validation/execution-v1/control-proposal/I4-PACKET-v1.json": { + "bytes": 1335, + "git_blob_sha1": "3884b084b45b9e3e3bd1f91c6b05b4cd13f8da49", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879" + }, + "validation/execution-v1/control-proposal/LEDGER-RECONCILIATION-v1.json": { + "bytes": 4139, + "git_blob_sha1": "d8f75fa552f92ad11db5783f4e8ac7c4e59a53c7", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + "validation/execution-v1/control-proposal/READBACK-COMMAND-v1.json": { + "bytes": 2909, + "git_blob_sha1": "a3a2c9a9500c8a60373bcfb66842f80ae50eb788", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + "validation/execution-v1/control-proposal/complete-fixed-o03-admission.json": { + "bytes": 33047, + "git_blob_sha1": "96d2d36b68131aa343563cee5c9907a3f6803066", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "validation/execution-v1/control/COMMAND-v1.json": { + "bytes": 2540, + "git_blob_sha1": "0072b2eecd891371ddce1b8dbe4f82febc24fc86", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "validation/execution-v1/control/EXEC-RESULT-v1.json": { + "bytes": 126, + "git_blob_sha1": "c752d1fcbf29fae3f77b38cb23e46c207250aa92", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "156917ce5281901a1a08ed1c98093e9c9fd361c28cf135863ffe27f4c0e0e01c" + }, + "validation/execution-v1/control/FAILURE-v1.json": { + "bytes": 1130, + "git_blob_sha1": "6dc341d4bfe0190e31d97cc9a337f455e5271384", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6f5381223a2cf6fb68fda081ecb723688c9237127865d397284ca6f3c585fc2b" + }, + "validation/execution-v1/control/I4-PACKET-v1.json": { + "bytes": 1335, + "git_blob_sha1": "3884b084b45b9e3e3bd1f91c6b05b4cd13f8da49", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879" + }, + "validation/execution-v1/control/LAUNCH-v1.json": { + "bytes": 581, + "git_blob_sha1": "8cc7a2aa1516f276b3106a768ee25b62f4986a50", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "92c8ee7129be80dd54ac8156a1b7a184344c53b44b845602f33cba6bfa03acf2" + }, + "validation/execution-v1/control/LEDGER-001.json": { + "bytes": 2406, + "git_blob_sha1": "54727ec9aabf569c6a12a4db0853b0e27a54e71c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "589b607e096d4ef7a49b38501827f1f5b865d1263591dff8b96cded9c7d62126" + }, + "validation/execution-v1/control/LEDGER-RECONCILIATION-v1.json": { + "bytes": 4139, + "git_blob_sha1": "d8f75fa552f92ad11db5783f4e8ac7c4e59a53c7", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + "validation/execution-v1/control/READBACK-COMMAND-v1.json": { + "bytes": 2909, + "git_blob_sha1": "a3a2c9a9500c8a60373bcfb66842f80ae50eb788", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + "validation/execution-v1/control/READBACK-EXEC-RESULT-v1.json": { + "bytes": 1583, + "git_blob_sha1": "63f739f57c5bb0c3a415b8b97142a198def85792", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f3e03d0875879b0dc3316bc1e5b34ea28be8d3c8600587320422c50e222e10cf" + }, + "validation/execution-v1/control/complete-fixed-o03-admission.json": { + "bytes": 33047, + "git_blob_sha1": "96d2d36b68131aa343563cee5c9907a3f6803066", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "validation/execution-v1/control/complete-fixed-o03-consumed": { + "bytes": 65, + "git_blob_sha1": "5288e16aca99b9ecf313e9762279b0465734cd37", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2a928d004026b4f90440b2cc970c2a851726e23c413d0dac086384f07e931c4c" + }, + "validation/execution-v1/control/outer-time.json": { + "bytes": 148, + "git_blob_sha1": "a8b5f46650c82884912cab62e2be6e7c218bd80e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a5435c2c21b838555a1c8201831cbab5ccef5c3dd0120972078c86d8a110fdfa" + }, + "validation/preparation/EVIDENCE-README-v2-before-run.md": { + "bytes": 3125, + "git_blob_sha1": "531b2be331b128fdc33cc25c85103170c6f74519", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a011c5dc4fa17b5e44f0631a5ed989929d3cdba3a7247328f4afa13cc32af043" + }, + "validation/rejected-envelope-v1/ADMISSION-TEMPLATE-v1.json": { + "bytes": 18528, + "git_blob_sha1": "8a9e3d4dfc88d76fe6e479ebcacddcc5539c1f77", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "30cb1f9d8ba4fb886a43793bf783f3fcdf69fa98cc658ee42eaacb26424825fe" + }, + "validation/rejected-envelope-v1/FIXED-SEQUENCE-v1.json": { + "bytes": 4529, + "git_blob_sha1": "41ccc68d6cb42a5b946849a60d8eef504fe35cb9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e156d8b8600d45b13646f24e46e8e6a3ac05b554c2df81d464447944c0e0095c" + }, + "validation/rejected-envelope-v1/OPERATION-BILL-v1.json": { + "bytes": 3577, + "git_blob_sha1": "d8b08d5d6f20e5b2da6388e1938eab9b47684971", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e7b0e21fdc01dc350ca5f71eb84757ae37161b527ea8eef82b14c63d9c79f97c" + }, + "validation/rejected-envelope-v1/PASSIVE-CHECKS-v1.json": { + "bytes": 1909, + "git_blob_sha1": "5b599edec19eff0e15aa09c7ba4323c905c38539", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e8a7c60e568ef9ea57b9ae612145d46dbd372aae9d053eedb4c034d2864a725e" + }, + "validation/rejected-envelope-v1/README-v1.md": { + "bytes": 7602, + "git_blob_sha1": "79d96219d5496b6a3e055a828678620dc74d97f8", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c5337759f784b15e5a45a937ce12e767aea23ed86b1e901efc79da0cbac06d84" + }, + "validation/rejected-envelope-v1/RUNTIME-PINS-v1.json": { + "bytes": 27394, + "git_blob_sha1": "aeafd6b9d7fda73d8e4755fdb990d0431078e839", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0" + }, + "validation/rejected-envelope-v1/RUNTIME-PINS-v1.sha256": { + "bytes": 65, + "git_blob_sha1": "6bdbafa68387ef34fcd11eef06a5cb29004fde3f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "067af3eb524cc3ea7a8389bac3ff93e50e14159565521977d7bede26f055ef42" + }, + "validation/rejected-envelope-v1/SOURCE-READINESS-v1.json": { + "bytes": 3504, + "git_blob_sha1": "51004ecdf64f90fc0735f82808aa69053101990e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e3f4f6e68b0dd7d66b2b269a346b09cfb315154c5a833cb05ed6db74e17101a2" + }, + "validation/rejected-envelope-v1/bootstrap.py": { + "bytes": 7884, + "git_blob_sha1": "075fad92cdb121afc20621872026ec97f274d98a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb" + }, + "validation/rejected-envelope-v1/custody.py": { + "bytes": 4943, + "git_blob_sha1": "c7aaad3522550914cb3ea865d12a364ade30e874", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87" + }, + "validation/rejected-envelope-v1/effective.py": { + "bytes": 4274, + "git_blob_sha1": "22b85b723dcf1da6913f2c8967948c1a22f4a63b", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830" + }, + "validation/rejected-envelope-v1/loader_controls.py": { + "bytes": 797, + "git_blob_sha1": "0e09204abcf9ce974886f8a5bcee428651a398c4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f" + }, + "validation/rejected-envelope-v1/observer.py": { + "bytes": 14564, + "git_blob_sha1": "fe3e9cfc05b1d28d3a1c1483198dfe0d64ce2a89", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4" + }, + "validation/rejected-envelope-v1/observer_controls.py": { + "bytes": 3694, + "git_blob_sha1": "655feb5eb5c39c02a65d31942bffe8ac18be01fd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e" + }, + "validation/rejected-envelope-v1/observer_fixture.py": { + "bytes": 2038, + "git_blob_sha1": "c2400182ddab1577e47d8adeb1805dd0629e9de9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0" + }, + "validation/rejected-envelope-v1/sequence_worker.py": { + "bytes": 4772, + "git_blob_sha1": "bb92d5bdba900afcb2899d1306dafba3f0706dc0", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557" + }, + "validation/rejected-envelope-v1/worker.py": { + "bytes": 6828, + "git_blob_sha1": "505a190e91891d919232295c9a1b5ee55e6d7224", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1" + }, + "validation/source-publication/EXPORT-EVIDENCE-v1.json": { + "bytes": 15742, + "git_blob_sha1": "7f25a771db71a176fcd3a1d4bd4b17263ddca299", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "1a5ef9e915dfc918142a648be2accd265c57746e497d995964263d10a5e8f8a4" + }, + "validation/source-publication/EXPORT-FREEZE-v1.json": { + "bytes": 15315, + "git_blob_sha1": "b46ec9fa1867587851100232073a0d2db40bd16c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5db374e8e9f8b69e574b2b24c4f4f3b8135927fbc044f1a2e7d3722ed05976f6" + }, + "validation/source-publication/EXPORT-REVIEW-v1.json": { + "bytes": 3368, + "git_blob_sha1": "c5a04dc2207f4a3e48f0ec8578e7a9dc71496d5b", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ccdfd212bd15fcbbf7092f1308088e500747f402e4a12cf188dc29426abd0949" + }, + "validation/source-publication/SOURCE-PR-EVIDENCE-v1.json": { + "bytes": 6852, + "git_blob_sha1": "8a6105be2f6109c1a93032d16a09df832777e7bc", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "afc874457238b443001d847458e0d1c9ca6088de109fe942dc2c4f08aef9db34" + }, + "validation/source-publication/SOURCE-PR-REVIEW-v1.json": { + "bytes": 1509, + "git_blob_sha1": "a6d51af7bcaebb0c6c6f6ce23281449794253b40", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "85070855f04019c112e186c388e7a673c5be01f6ef11ecb52d54891ae1228f2d" + }, + "validation/source-publication/SOURCE-REMOTE-EVIDENCE-v1.json": { + "bytes": 16541, + "git_blob_sha1": "52f475dbec649a58d5fdc46342d13c1be782d09b", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "cddbcb07d6edb29d11c8b167d76aa43f3522522a6c96e46e96ec62a71ec1376f" + }, + "validation/source-publication/SOURCE-REMOTE-REVIEW-v1.json": { + "bytes": 1419, + "git_blob_sha1": "accc77418ec146a5d82a00c9f5f9f5bd76ab1d58", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5ca5a19b5b70703686386afd281024e64f6b396888207788247a885e51203595" + }, + "validation/source-publication/TREE-ENTRIES-v1.json": { + "bytes": 10934, + "git_blob_sha1": "aa5d7c33ecf8b1b3fc052237bf11281f568da275", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "d1dd1293ab73b997fcca153a5bc446a56753c75e307ef1898726dd2e20478ca1" + }, + "validation/source-reviews/COMBINED-SOURCE-REVIEW-v1.json": { + "bytes": 1025, + "git_blob_sha1": "00099b55c2f69accc0381001e46a0c0d38becd44", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f73a19d43ee254b3fdafaaccfa3439ffdda87f84067213a8a39d5393668226d0" + }, + "validation/source-reviews/FAILURE-EVIDENCE-v1.json": { + "bytes": 4736, + "git_blob_sha1": "567636a49722d0faf8d5ac1ffc7f6450b7ef486e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ec4d513db9138a015e5ee74c78c983317cd4a48c55def64e2f55b87495bbad6c" + }, + "validation/source-reviews/FAILURE-REVIEW-v1.json": { + "bytes": 8295, + "git_blob_sha1": "0a73cb655963a01f6ca02a9873cf817b4e756e01", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5979a7939926bb01a3d2f9a44e59a502ab0d0415abf275f5d7331a5450aea5ea" + }, + "validation/source-reviews/I3-REVIEW-v1.json": { + "bytes": 4168, + "git_blob_sha1": "37b1e7056e7b88d711f95f89471e736e04212dd4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "33113ecfebd19c41caa370f6da3591d38febe51e97a62c0c11a310921d4c0ebd" + }, + "validation/source-reviews/I3-REVIEW-v2.json": { + "bytes": 7558, + "git_blob_sha1": "6257939348707dc7df5ab96bb32aa1bdb16d0796", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "48f7b45833b003bf2283ca3e6befbd12a511faab34810115b0d350150aa0c12f" + }, + "validation/source-reviews/I3-v1-EVIDENCE.json": { + "bytes": 16983, + "git_blob_sha1": "a1dfc4fd1d08b458a1e10950266cffce92a514d3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "38b33d6b0f9d1fdcf94a88716db8d2ddcf343a5ec2446a271c6500d45ca2394f" + }, + "validation/source-reviews/I3-v1-REJECTION-SUPPLEMENT.json": { + "bytes": 1981, + "git_blob_sha1": "1cc8dc1ea03e7b6cc13115a894bd7e8999c24525", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e5f22cfcea5e19a3547b7fbd9c8fcba5c9e004d71a662d6d97db7088250e8199" + }, + "validation/source-reviews/I3-v1-SNAPSHOT-PINS.json": { + "bytes": 4587, + "git_blob_sha1": "5a584f23465d9578451739dfe083d59d141021e9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "bae6543afe3da6294243bec071988590da2759905fa4bf4caee78685ffc34ef5" + }, + "validation/source-reviews/I3-v2-EVIDENCE.json": { + "bytes": 11735, + "git_blob_sha1": "b706256dac8b934b23207dbaa78affe8c0475701", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8a078e15b9b65b3e39c140f86dbce0b818b6a2f9179a8e49804eeb502033ed51" + }, + "validation/source-reviews/I4-EVIDENCE-v1.json": { + "bytes": 21898, + "git_blob_sha1": "4ba1dae6d7f55c72363c2395ddabcff58bd89d43", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f377928429089b17c15b282a59588d32c79fdcccafdd28c3a28c0feaf111e12b" + }, + "validation/source-reviews/I4-REVIEW-v1.json": { + "bytes": 5001, + "git_blob_sha1": "5e9b7751e2f5a062f65e46064d9ba1b8ce6c14e2", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2affb5c91dfe0d41e3b9392b115ff6a135eb1a69d10673b7671bff34d6dc32da" + } + }, + "historical_manifest": "PACKAGE-MANIFEST-v1.json retains exact first-source-export50-entry scope, not later tree census.", + "original51sourcefiles_unchanged": true, + "schema": "h25-authentic-serializer-complete-evidence-manifest-v2", + "self_excluded": "PACKAGE-MANIFEST-v2.json; external EXPORT-FREEZE-v2.json seals complete tree including this manifest" +} diff --git a/research/h25-authentic-serializer-20261031/PUBLIC-OUTCOME-v2.json b/research/h25-authentic-serializer-20261031/PUBLIC-OUTCOME-v2.json new file mode 100644 index 0000000000..8abe5981cd --- /dev/null +++ b/research/h25-authentic-serializer-20261031/PUBLIC-OUTCOME-v2.json @@ -0,0 +1,58 @@ +{ + "I5_I6_I7_qualified": false, + "O03_qualified": false, + "actual_fixed_attempts": 1, + "checkpoint_state": { + "I1": "ACCEPTED", + "I2": "ACCEPTED", + "I3_current": "INVALIDATED_KNOWN_INCOMPLETE", + "I3_historical_source_acceptance": "PRESERVED", + "I4_current": "CONSUMED_FAILED_CLOSED_NO_CURRENT_PASSED_CREDIT", + "I4_historical_dispatch_authorization": "PRESERVED_AUTHORIZED_FAIL_CLOSED", + "current_valid_checkpoints": 2, + "denominator": 8, + "failure_evidence_credit": 0, + "failure_resets_progress_clock": false, + "historical_high_water": 4 + }, + "failure_observations": { + "observer_group_sampled_peak_bytes": 19726336, + "observer_samples": 24, + "outer_exit": 1, + "outer_individual_maxrss_kib": 19392, + "outer_system_seconds": 0.06, + "outer_user_seconds": 0.26, + "outer_wall_seconds": 0.33, + "performance_or_resource_fit_evidence": false + }, + "fresh_execution_authorization": false, + "full_baseline_candidate_replays": 0, + "historical_first_source_manifest": "PACKAGE-MANIFEST-v1.json; unchanged51-file first export bound by validation/source-publication/EXPORT-FREEZE-v1.json", + "independent_failure_review": { + "O03_qualification_decision": "REJECT_NO_QUALIFYING_EXECUTED_EVIDENCE", + "decision": "ACCEPT_RETAINED_FAILURE_ATTRIBUTION_AND_SCOPED_POLICY_ACCOUNTING", + "path": "validation/source-reviews/FAILURE-REVIEW-v1.json", + "sha256": "5979a7939926bb01a3d2f9a44e59a502ab0d0415abf275f5d7331a5450aea5ea" + }, + "independent_full_output_validations": 0, + "measured_gain": null, + "original_goal_credit_added": 0, + "physical_costs": "FAILED_ATTEMPT_AND_CONTROLLER_READBACK_REPORT_PUBLICATION_OPEN_NOT_ZERO", + "policy": { + "attempt_charge_seconds": "0.34", + "charge_basis": "Preserved GNUtime0.33s outer wall plus0.01s rounding; manual accounting interpretation, declared readback failed.", + "existing_cap_seconds": 2400, + "prior_seconds": "94.210533479", + "total_seconds": "94.550533479" + }, + "primary_error": "unsealed mapped files: ['/usr/lib/locale/locale-archive']", + "raw_outer_time_preserved": true, + "retry_executions": 0, + "schema": "o03-retained-first-failure-public-outcome-v2", + "secondary_error": "Declared single parent_readback.py json.loads rejected GNUtime nonzero-status prefix before report creation.", + "source_commit": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "source_repairs_after_failure": 0, + "status": "STOP_BEFORE_WORKER_OR_TARGET_IMPORT", + "successful_parent_readback_report": false, + "target_controls_executed": 0 +} diff --git a/research/h25-authentic-serializer-20261031/README.md b/research/h25-authentic-serializer-20261031/README.md new file mode 100644 index 0000000000..9d10762100 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/README.md @@ -0,0 +1,19 @@ +# Authentic retained-value H25 serializer sources + +This source-only package adds the authentic fixed-input loader and complete retained-value baseline/candidate consumer to the bounded serializer extracted in [PR6326](https://github.com/CrocSwap/integer-mult-bounds/pull/6326). Independent source reviews accept I1 and I2 in their complete stated source scopes. No target import, control, decompression, full-data replay or benchmark has been performed in this implementation round at this source-export freeze. This package does not qualify O03. + +`loader/` contains strict transport/logical authentication, JSON/schema restoration and 39 ordered loader controls per mode. `consumer/` contains the complete consumer, a separate validator that imports no candidate/loader/reference module, the exact original reference/candidate and 70 old controls plus 15 new consumer controls per mode. The four original reference/candidate/control files are byte-identical to their accepted predecessor. Normal and optimized control outcomes remain unexecuted requirements. + +`inputs/baseline/evidence/canonical/` carries the complete three authentic transports, 17,022,954 bytes. Their sizes, SHA256 and Git blob IDs are recorded in `provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json`; the parent's independent upstream/fork metadata verification is in `provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json`. These bytes originate from PR6029 commit `e05aad954689d0ee21baff19b4674f1fcb2e838f`. Input presence and exact transport identity do not establish logical/schema eligibility, custody, resource fit or output correctness. The fixed writer outputs remain 527-byte result, 58,143,622-byte witness and 2,674,272-byte ordered rank trace: 60,818,421 bytes, 59,959 rank events and 252 distinct row tuples. Original EXPECTED and exact bool/finite-float/exact-int roles remain unchanged. + +The source modules use sibling `loader/` and `consumer/` directories. Their accepted CLI and supplied-custody interfaces are described in `loader/API-v1.md`, `consumer/README-v1.md` and `consumer/DEPENDENCIES-v1.json`. Those command forms describe source interfaces; they are not an admitted clone-and-run procedure. No runtime/guard/custody helper is supplied here. I3 actual source/runtime/provider/observer/guard closure and I4 parent exact-operation admission remain pending. This source export excludes the evolving envelope. + +A future admitted operation must create separately owned fresh input/source stages, retain the exact expected three-file relative layout, establish actual canonical absolute root and metadata identities, real0555 input directories, unique regular0444 files and fresh before/after bindings. Each arm and independent validator receives its own input/custody contract and fresh external output/receipt paths. Git records100644 files and does not preserve0444/0555 permissions, owners or inode identities. A checkout or a fabricated custody JSON is insufficient. The illustrative identity values in the accepted API are schema examples, never valid saved execution authorization. + +Q1-Q5 and every P0-P5 operation in the carried feasibility review/probe specification remain mandatory. Parent execution is serialized under the existing2400-second guarded allowance,180-second command and sampled1GiB process-group cap, including failures and observer costs. No new budget, smaller synthetic substitute, reroll or automatic retry is granted. Source acceptance proves neither resource fit nor gain. Inclusive setup/import/loading/encoding/copy/control/validation/cleanup costs must be measured; sampled simultaneous group RSS and individual maxRSS remain distinct. Final observer-write/parent-readback/publication overhead remains OPEN_NOT_ZERO. + +A later evidence commit may report independently reviewed execution and unchanged-O03 qualification or retain a failed/nonqualifying operation. This commit contains no executed evidence and makes no full scientific-caller, O02/O07/O08/O09/O10, historical F7/timing-gap, whole-goal or kappa claim. Original denominators and paused unrelated research remain unchanged. Hosted package planning success would be separate from replay; skipped replay is not replay evidence. This package is not registered to start unreviewed hosted execution. + +`SOURCES-EXPORT-v1.json` maps every copied source/proof/input to its original workspace path, exact hash and modes. Those paths inside provenance records identify historical source locations; executable imports use the included sibling files. `PACKAGE-MANIFEST-v1.json` seals all package files except itself; the external export freeze seals that manifest and the full tree. `SOURCES.json` and `TASK.json` state the present dependency and admission boundaries. No scientific/native provenance module is imported by the delivered consumer. + +Prepared for Clear1nsight with substantial OpenAI Codex assistance, using GPT-6.1-sol high source and independent review agents. Original CrocSwap/integer-mult-bounds authors and the PR6029/PR6326 predecessors retain credit. The repository Apache-2.0 license applies. This is source preparation for a scoped draft PR; no merge is authorized. diff --git a/research/h25-authentic-serializer-20261031/SOURCES-EXPORT-v1.json b/research/h25-authentic-serializer-20261031/SOURCES-EXPORT-v1.json new file mode 100644 index 0000000000..435ba23c03 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/SOURCES-EXPORT-v1.json @@ -0,0 +1,472 @@ +{ + "copied_files": [ + { + "bytes": 5012, + "export_mode_octal": "0o444", + "git_blob_sha1": "ec051bd35aad548258708278b146a037908a7dfa", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/API-v1.md", + "package_path": "loader/API-v1.md", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + { + "bytes": 2002, + "export_mode_octal": "0o444", + "git_blob_sha1": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/CONTROL-SPEC-v1.json", + "package_path": "loader/CONTROL-SPEC-v1.json", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + { + "bytes": 586, + "export_mode_octal": "0o444", + "git_blob_sha1": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PASSIVE-ATTEMPTS-v1.json", + "package_path": "loader/PASSIVE-ATTEMPTS-v1.json", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + { + "bytes": 2395, + "export_mode_octal": "0o444", + "git_blob_sha1": "b584cb6cdee15071f76918e1055a224000c5f255", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json", + "package_path": "loader/SOURCE-PINS-v1.json", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + { + "bytes": 2306, + "export_mode_octal": "0o444", + "git_blob_sha1": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-READINESS-v1.json", + "package_path": "loader/SOURCE-READINESS-v1.json", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + { + "bytes": 14650, + "export_mode_octal": "0o444", + "git_blob_sha1": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py", + "package_path": "loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + { + "bytes": 13181, + "export_mode_octal": "0o444", + "git_blob_sha1": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py", + "package_path": "loader/frozen_input_controls.py", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + }, + { + "bytes": 1152, + "export_mode_octal": "0o444", + "git_blob_sha1": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PACKAGE-PINS-v1.json", + "package_path": "loader/PACKAGE-PINS-v1.json", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71" + }, + { + "bytes": 736, + "export_mode_octal": "0o444", + "git_blob_sha1": "cab48c3a31b095e78253899bff95548e44a32e6f", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json", + "package_path": "consumer/CONSUMER-CONTROL-SPEC-v1.json", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + { + "bytes": 3062, + "export_mode_octal": "0o444", + "git_blob_sha1": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONTROL-SPEC.json", + "package_path": "consumer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + { + "bytes": 3934, + "export_mode_octal": "0o444", + "git_blob_sha1": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json", + "package_path": "consumer/DEPENDENCIES-v1.json", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + { + "bytes": 719, + "export_mode_octal": "0o444", + "git_blob_sha1": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-ATTEMPTS-v1.json", + "package_path": "consumer/PASSIVE-ATTEMPTS-v1.json", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + { + "bytes": 2637, + "export_mode_octal": "0o444", + "git_blob_sha1": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-CHECKS-v1.json", + "package_path": "consumer/PASSIVE-CHECKS-v1.json", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + { + "bytes": 6609, + "export_mode_octal": "0o444", + "git_blob_sha1": "8879b820a9c05c78857964f0674ae4c4806a7726", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/README-v1.md", + "package_path": "consumer/README-v1.md", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + { + "bytes": 2081, + "export_mode_octal": "0o444", + "git_blob_sha1": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/SOURCE-READINESS-v1.json", + "package_path": "consumer/SOURCE-READINESS-v1.json", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + { + "bytes": 23560, + "export_mode_octal": "0o444", + "git_blob_sha1": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py", + "package_path": "consumer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + { + "bytes": 9411, + "export_mode_octal": "0o444", + "git_blob_sha1": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py", + "package_path": "consumer/full_consumer.py", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + { + "bytes": 2141, + "export_mode_octal": "0o444", + "git_blob_sha1": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py", + "package_path": "consumer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + { + "bytes": 6630, + "export_mode_octal": "0o444", + "git_blob_sha1": "1926eb081f24a953f1521ee63555fe7910a26e05", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py", + "package_path": "consumer/run_controls.py", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + { + "bytes": 23684, + "export_mode_octal": "0o444", + "git_blob_sha1": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py", + "package_path": "consumer/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + { + "bytes": 14577, + "export_mode_octal": "0o444", + "git_blob_sha1": "ade0aa6b46e28531797062f73b664efc8705f445", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py", + "package_path": "consumer/validate_outputs.py", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + }, + { + "bytes": 2453, + "export_mode_octal": "0o444", + "git_blob_sha1": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PACKAGE-PINS-v1.json", + "package_path": "consumer/PACKAGE-PINS-v1.json", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc" + }, + { + "bytes": 5166, + "export_mode_octal": "0o444", + "git_blob_sha1": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I1-REVIEW-v1.json", + "package_path": "reviews/I1-REVIEW-v1.json", + "sha256": "ba00118a5c665beb5dbc12f22bf85f47c90d7bc676e4a98d3b901616cbafb115" + }, + { + "bytes": 2211, + "export_mode_octal": "0o444", + "git_blob_sha1": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I1-EVIDENCE-v1.json", + "package_path": "reviews/I1-EVIDENCE-v1.json", + "sha256": "2e416ae27c6e79372e4b22d7c8ac212880e99f431504f278740e1dd2b6033aeb" + }, + { + "bytes": 4600, + "export_mode_octal": "0o444", + "git_blob_sha1": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I2-REVIEW-v1.json", + "package_path": "reviews/I2-REVIEW-v1.json", + "sha256": "ef8b3f12d33ce85277b90c9727545db0252c3104eb6e81444f0b82448c61881e" + }, + { + "bytes": 5912, + "export_mode_octal": "0o444", + "git_blob_sha1": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I2-EVIDENCE-v1.json", + "package_path": "reviews/I2-EVIDENCE-v1.json", + "sha256": "54567df4f843827537c9ce1a5e472f592afa6ac1462832dcad558e2f6a363c1d" + }, + { + "bytes": 6135, + "export_mode_octal": "0o444", + "git_blob_sha1": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/PLAN-v1.md", + "package_path": "provenance/implementation/PLAN-v1.md", + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234" + }, + { + "bytes": 1169, + "export_mode_octal": "0o444", + "git_blob_sha1": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/control/AUTHORIZATION-v1.json", + "package_path": "provenance/implementation/control/AUTHORIZATION-v1.json", + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2" + }, + { + "bytes": 3351, + "export_mode_octal": "0o444", + "git_blob_sha1": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/control/REMOTE-INPUT-OBJECTS-v1.json", + "package_path": "provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json", + "sha256": "b39edf02587bb99c1464fab8d9bd9ea531a5bc6448eda92b95d841b4baa4fa54" + }, + { + "bytes": 10656, + "export_mode_octal": "0o444", + "git_blob_sha1": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/review/REVIEW-v1.json", + "package_path": "provenance/feasibility/review/REVIEW-v1.json", + "sha256": "387ce2469788a5b93e35abb5472780d8421a065fd91b7ebcb1044cf8af0a9780" + }, + { + "bytes": 18742, + "export_mode_octal": "0o444", + "git_blob_sha1": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/contract/O03-MATRIX-v1.json", + "package_path": "provenance/feasibility/contract/O03-MATRIX-v1.json", + "sha256": "99720019aaec5273e9da703e83c1795741a8d0fbba1b3d0e9b571dca2f4fe60c" + }, + { + "bytes": 9046, + "export_mode_octal": "0o444", + "git_blob_sha1": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/contract/DECISION-v1.json", + "package_path": "provenance/feasibility/contract/DECISION-v1.json", + "sha256": "6d9bf443793f6ca6eaef574faa7935a52d8f510abcb0ae8371d59b608ba1a9c8" + }, + { + "bytes": 11830, + "export_mode_octal": "0o444", + "git_blob_sha1": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/technical/PROBE-SPEC-v1.json", + "package_path": "provenance/feasibility/technical/PROBE-SPEC-v1.json", + "sha256": "a5885aea89261a3b1aa024e6771ed299845f4b587833a9e9e97b70802eefa2d7" + }, + { + "bytes": 11462, + "export_mode_octal": "0o444", + "git_blob_sha1": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/technical/FEASIBILITY-v1.json", + "package_path": "provenance/feasibility/technical/FEASIBILITY-v1.json", + "sha256": "ce706af4d4092be6f23c69aa5d2dc66929442c182f18a34366f4ba8e5cf53f27" + }, + { + "bytes": 12719, + "export_mode_octal": "0o444", + "git_blob_sha1": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/technical/SOURCE-PINS-v1.json", + "package_path": "provenance/feasibility/technical/SOURCE-PINS-v1.json", + "sha256": "ad7fb8b6ac220879c6bdbb59d458d86067eabc60237378f2f396df80c1e0d9ae" + }, + { + "bytes": 2031, + "export_mode_octal": "0o444", + "git_blob_sha1": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/REFERENCE-EXTRACTION.json", + "package_path": "provenance/original-serializer/REFERENCE-EXTRACTION.json", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + { + "bytes": 3032, + "export_mode_octal": "0o444", + "git_blob_sha1": "1767b5809d01af10dd64eb528b37f22049c53734", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/ORIGINAL-SOURCE-PINS.json", + "package_path": "provenance/original-serializer/ORIGINAL-SOURCE-PINS.json", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + { + "bytes": 20334, + "export_mode_octal": "0o444", + "git_blob_sha1": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/provenance/native_backend.py", + "package_path": "provenance/original-serializer/provenance/native_backend.py", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + { + "bytes": 8959, + "export_mode_octal": "0o444", + "git_blob_sha1": "807855eb875673c47da0ed1b5a890a417e28a846", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/provenance/profile_side_verifier.py", + "package_path": "provenance/original-serializer/provenance/profile_side_verifier.py", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + { + "bytes": 10571, + "export_mode_octal": "0o444", + "git_blob_sha1": "d94920c274c0a47db9763dd595230d52df0bd073", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/provenance/compare_side_verifier.py", + "package_path": "provenance/original-serializer/provenance/compare_side_verifier.py", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + { + "bytes": 16995263, + "export_mode_octal": "0o444", + "git_blob_sha1": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "package_path": "inputs/baseline/evidence/canonical/witness.json.gz", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + { + "bytes": 22029, + "export_mode_octal": "0o444", + "git_blob_sha1": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "package_path": "inputs/baseline/evidence/canonical/rank-trace.json.gz", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + { + "bytes": 5662, + "export_mode_octal": "0o444", + "git_blob_sha1": "62a6091887a3894535c1d059e1b0c527d556eb76", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "package_path": "inputs/baseline/evidence/canonical/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + { + "bytes": 2945, + "export_mode_octal": "0o444", + "git_blob_sha1": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "git_mode": "100644", + "original_mode_octal": "0o664", + "original_workspace_path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json", + "package_path": "provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json", + "sha256": "5b44b61996e11eae2d495fbdfbd20e221fac99937a44491dff3166af45466c6d" + }, + { + "bytes": 14285, + "export_mode_octal": "0o444", + "git_blob_sha1": "97b016c958d3e309ef884213fda3328388f69e58", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "package_path": "provenance/original-goal/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e" + }, + { + "bytes": 6249, + "export_mode_octal": "0o444", + "git_blob_sha1": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "git_mode": "100644", + "original_mode_octal": "0o444", + "original_workspace_path": "outputs/h25-data-handling-20261028/control/hourly-progress/RUBRIC-v1.json", + "package_path": "provenance/original-goal/control/hourly-progress/RUBRIC-v1.json", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1" + } + ], + "execution_admitted": false, + "mode_boundary": "Copied source/input/proof files are0444 locally for review. Git records100644 and does not retain0444/0555 or inode/owner metadata; fresh runtime/input staging remains unadmitted I3/I4.", + "relocation": "Exact source bytes retain sibling loader/consumer imports. Provenance paths inside copied records are historical original workspace paths, resolved by this mapping, not runtime file lookups. Inputs are carried at inputs/baseline/evidence/canonical; fresh separately owned staged copies/custody are required.", + "schema": "h25-authentic-serializer-source-export-v1", + "source_acceptance": { + "I1": "ba00118a5c665beb5dbc12f22bf85f47c90d7bc676e4a98d3b901616cbafb115", + "I2": "ef8b3f12d33ce85277b90c9727545db0252c3104eb6e81444f0b82448c61881e" + } +} diff --git a/research/h25-authentic-serializer-20261031/SOURCES.json b/research/h25-authentic-serializer-20261031/SOURCES.json new file mode 100644 index 0000000000..a8e576f93e --- /dev/null +++ b/research/h25-authentic-serializer-20261031/SOURCES.json @@ -0,0 +1,37 @@ +{ + "accepted_lanes": { + "I1": "reviews/I1-REVIEW-v1.json", + "I2": "reviews/I2-REVIEW-v1.json" + }, + "copied_file_count": 46, + "evidence": "reviews/I1-EVIDENCE-v1.json and reviews/I2-EVIDENCE-v1.json are passive source evidence only.", + "execution_admitted": false, + "manifest_self_reference": "PACKAGE-MANIFEST-v1.json excludes itself; external publication/EXPORT-FREEZE-v1.json contains full tree including manifest.", + "operation_prerequisites": "provenance/feasibility/technical/PROBE-SPEC-v1.json", + "schema": "h25-authentic-serializer-source-description-v1", + "scope_contract": "provenance/feasibility/contract/O03-MATRIX-v1.json", + "source_dependency_closure": { + "consumer_modules": [ + "consumer/reference.py", + "consumer/bounded_serialization.py", + "consumer/serialization_controls.py", + "consumer/full_consumer.py", + "consumer/run_controls.py", + "consumer/validate_outputs.py" + ], + "inputs": "Included exact three transports beneath inputs/baseline/evidence/canonical; supplied custody needs separately owned actual stages, not Git checkout metadata.", + "loader_modules": [ + "loader/frozen_h25_inputs.py", + "loader/frozen_input_controls.py" + ], + "no_hidden_workspace_runtime_dependency": "Provenance paths and inherited source manifests retain their historical spelling; they are source identity records, not executable dependency resolution.", + "runtime": "Host CPython3.12/Linux standard-library/native/provider/binary/callable closure must be separately authenticated; import declarations are not actual runtime admission.", + "specifications": [ + "consumer/CONTROL-SPEC.json", + "consumer/CONSUMER-CONTROL-SPEC-v1.json", + "loader/CONTROL-SPEC-v1.json" + ] + }, + "source_map": "SOURCES-EXPORT-v1.json", + "unchanged_reference_ancestry": "provenance/original-serializer/REFERENCE-EXTRACTION.json and included original provenance source files" +} diff --git a/research/h25-authentic-serializer-20261031/TAKEOVER-v2.md b/research/h25-authentic-serializer-20261031/TAKEOVER-v2.md new file mode 100644 index 0000000000..a54ec50286 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/TAKEOVER-v2.md @@ -0,0 +1,11 @@ +# Takeover after the retained first failure + +Current checkpoint: I1/I2 accepted; I3 INVALIDATED_KNOWN_INCOMPLETE after the missing locale map and failed readback; I4 CONSUMED_FAILED_CLOSED with no current passed credit. Current valid2/8; historical high-water4. Historical I3 source acceptance and authorized once-only I4 dispatch remain preserved, not retroactively unauthorized. One failed first operation stopped before worker/target import. Controls/replays/independent complete output validation:0. O03 and I5/I6/I7 unqualified; no measured gain. Existing canonical charge94.550533479/2400 policy seconds; whole physical costs remain OPEN_NOT_ZERO. The source PR begins at bc88937088bdd9f4f71fbdc9246dbf58b11eb725; this evidence package preserves the exact rejected and accepted sources, admission, raw failure and independent dispositions. + +Failure-evidence acceptance adds0 credit and resets no progress clock. There is no remaining permission to retry or change source in this round. Preserve the consumed marker, failed closing readback, raw GNUtime prefix, all original51 source-export files, source repair/rejection ancestry and independent reviews. Do not treat a source-only acceptance, hosted planning success, pin match or failure observation as saved runtime PASS. + +A future explicitly authorized round must first investigate the actual locale-archive runtime-map closure failure and the closing-readback nonzero-prefix handling from these exact sources. Any proposed repair needs fresh complete independent source/runtime/custody/bill review; this handoff neither implements nor approves a fix. New exact operation/admission and canonical ledger/lock reconciliation must precede target work. No synthetic replacement, adaptive split, smaller dataset, automatic retry or numerical performance promise is inherited. + +The unchanged O03 route still requires concrete old/new/observer control outcomes in normal/-O, genuine first complete baseline/candidate with bounded candidate fast path, complete independently validated outputs/receipts/custody/cleanup, and independently accepted inclusive memory/cost/gain-or-no-gain evidence under the original Q1-Q5/P0-P5 scope. Full caller and global costs remain separate original obligations. No scientific construction, cache, retention or mathematics is resumed by this handoff. + +Absolute host paths/runtime objects are evidence. Fresh execution elsewhere requires new actual host/input/source/provider identities, immutable staging and explicit admission. Keep native controller/initial unsampled window/final observer/readback/reconciliation/review/publication and historical gaps explicit; do not claim true continuous group peak or all-guard CPU/RSS. Publication alone supplies no new execution qualification. diff --git a/research/h25-authentic-serializer-20261031/TASK.json b/research/h25-authentic-serializer-20261031/TASK.json new file mode 100644 index 0000000000..df9d7b6886 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/TASK.json @@ -0,0 +1,36 @@ +{ + "command_seconds_cap": 180, + "entrypoints": { + "consumer": "consumer/full_consumer.py --arm baseline|candidate; consumer/run_controls.py finite controls", + "loader": "loader/frozen_h25_inputs.py supplied-custody API; loader/frozen_input_controls.py ordered controls", + "validator": "consumer/validate_outputs.py independent complete output validation" + }, + "execution_admitted": false, + "existing_guarded_seconds_cap": 2400, + "hosted_replay_registered": false, + "next_requirements": [ + "Independent exact source export acceptance.", + "I3 actual immutable input/source/runtime/provider/bootstrap/guard/sampler/observer closure and complete paid boundary acceptance.", + "I4 parent exact operation and refreshed canonical ledger admission.", + "I5 ordered old/new/observer normal and optimized controls.", + "I6 fixed first authentic full baseline/candidate and independent output/custody/cleanup validation.", + "I7 independent inclusive measurement and qualification/no-gain/regression/failure disposition." + ], + "no_new_budget": true, + "outside_tail": "OPEN_NOT_ZERO", + "retry_reroll_resize": false, + "sampled_group_bytes_cap": 1073741824, + "schema": "h25-authentic-serializer-source-task-v1", + "scope": "Complete authentic retained-value serializer source only; unchanged O03 eligibility remains conditional on Q1-Q5/P0-P5.", + "source_does_not_establish": [ + "executed controls", + "actual full-data schema/fast-path acceptance", + "output equality", + "runtime/source/input custody", + "180s/1GiB fit", + "measured gain", + "O03 qualification", + "full caller or whole-goal completion" + ], + "status": "I1_I2_SOURCE_ACCEPTED_I3_I4_PENDING_UNEXECUTED" +} diff --git a/research/h25-authentic-serializer-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json b/research/h25-authentic-serializer-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json new file mode 100644 index 0000000000..cab48c3a31 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json @@ -0,0 +1,27 @@ +{ + "modes": [ + 0, + 1 + ], + "new_count_per_mode": 15, + "new_ordered_cases": [ + "legitimate-bool-float-slots", + "ordered-duplicate-ranks", + "literal-fallback-no-credit", + "int-only-rank-bool-fallback-no-credit", + "missing-marker-no-credit", + "faults-enabled-no-credit", + "incomplete-phase-no-credit", + "missing-batches-no-credit", + "oversize-batch-no-credit", + "wrong-copy-limit-no-credit", + "missing-file-counter-no-credit", + "wrong-byte-counter-no-credit", + "digest-copy-mismatch-no-credit", + "incomplete-cleanup-no-credit", + "missing-stage-no-credit" + ], + "schema": "h25-o03-consumer-control-spec-v1", + "status": "SOURCE_ONLY_UNEXECUTED", + "unchanged_old_count_per_mode": 70 +} diff --git a/research/h25-authentic-serializer-20261031/consumer/CONTROL-SPEC.json b/research/h25-authentic-serializer-20261031/consumer/CONTROL-SPEC.json new file mode 100644 index 0000000000..38c8aaa25b --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/CONTROL-SPEC.json @@ -0,0 +1,94 @@ +{ + "count_per_mode": 70, + "coverage_boundary": [ + "Exact70 concrete cases are the execution specification; prose bill families are broader than separately exercised variants.", + "No separate tuple/str/float subclass case, circular-dict case, every-artifact-position subclass cross-product, middle/final-fragment stage hash injection, ENOSPC-specific byte budget or every missing/extra schema-key variant appears in this70-case suite. Do not claim those distinct variants executed.", + "Full H25 original/candidate equality, normal/O execution, shared-observer interaction and complete resource measurements remain outstanding." + ], + "modes": [ + { + "name": "normal", + "optimization": 0 + }, + { + "name": "optimized", + "optimization": 1 + } + ], + "ordered_cases": [ + "ordinary", + "empty", + "rows-1", + "rows-1023", + "rows-1024", + "rows-1025", + "rows-2048", + "byte-bound-169", + "byte-bound-170", + "byte-bound-171", + "scalars-unicode-wide", + "wide-unlimited", + "wide-digit-error", + "interned-rank-rows", + "depth-30", + "depth-33", + "circular", + "callback-list", + "callback-dict", + "callback-error", + "int-subclass", + "unsupported-object", + "malformed-result", + "malformed-witness", + "malformed-rank", + "nonstring-supported-keys", + "expected-result_sha256", + "expected-exact_witness_sha256", + "expected-rank_trace_sha256", + "expected-rank_call_count", + "expected-rank_distinct_matrix_count", + "failure-stage_create", + "failure-stage_open", + "failure-stage_write", + "failure-stage_flush", + "failure-stage_after_close", + "failure-stage_hash", + "failure-final_open-result.json", + "failure-final_write-result.json", + "failure-final_flush-result.json", + "failure-final_after_close-result.json", + "failure-final_open-witness.json", + "failure-final_write-witness.json", + "failure-final_flush-witness.json", + "failure-final_after_close-witness.json", + "failure-final_open-rank-trace.json", + "failure-final_write-rank-trace.json", + "failure-final_flush-rank-trace.json", + "failure-final_after_close-rank-trace.json", + "short-final-0", + "short-final-1", + "copy-corrupt-content", + "stage-mutated-size", + "copy-read-error", + "copy-hash-error", + "cleanup-unlink-error", + "cleanup-rmdir-error", + "primary-plus-close-error", + "primary-plus-manifest-error", + "drift-reference_global", + "drift-json_default", + "drift-expected_value", + "drift-effective_builtin", + "drift-json_global_shadow", + "drift-keyword_default", + "exit-json-drift", + "fallback-exit-json-drift", + "existing-finals", + "state-mutation-between-writes", + "path-subclass-fallback" + ], + "runner_sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "schema": "h25-serializer-component-control-spec-v1", + "source_review_sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555", + "status": "SOURCE_SPEC_ONLY_NOT_EXECUTED" +} diff --git a/research/h25-authentic-serializer-20261031/consumer/DEPENDENCIES-v1.json b/research/h25-authentic-serializer-20261031/consumer/DEPENDENCIES-v1.json new file mode 100644 index 0000000000..b864f9a83a --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/DEPENDENCIES-v1.json @@ -0,0 +1,133 @@ +{ + "complete_local_source_modules": [ + "reference.py", + "bounded_serialization.py", + "serialization_controls.py", + "full_consumer.py", + "run_controls.py", + "validate_outputs.py" + ], + "created_utc": "2026-10-31T08:11:27.417843+00:00", + "execution_contract": { + "arm": "full_consumer.py --arm baseline|candidate --input-root INPUT --custody-json CUSTODY --output-root FRESH --receipt FRESH", + "controls": "run_controls.py --output-root FRESH --receipt FRESH", + "validator": "validate_outputs.py --input-root INPUT --custody-json CUSTODY --baseline-root B --candidate-root C --baseline-receipt BR --candidate-receipt CR --report FRESH" + }, + "external_local_source_dependencies": [ + { + "bytes": 14650, + "path": "../loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + } + ], + "forbidden_imports": [ + "scientific comparison/profile modules", + "native_backend", + "ctypes", + "subprocess", + "network clients" + ], + "imports_per_source": { + "bounded_serialization.py": [ + "__future__", + "_json", + "contextlib", + "hashlib", + "json", + "json.encoder", + "os", + "pathlib", + "stat", + "tempfile", + "types" + ], + "full_consumer.py": [ + "__future__", + "argparse", + "bounded_serialization", + "frozen_h25_inputs", + "hashlib", + "json", + "os", + "pathlib", + "reference", + "stat", + "sys", + "time" + ], + "reference.py": [ + "hashlib", + "json" + ], + "run_controls.py": [ + "__future__", + "argparse", + "bounded_serialization", + "copy", + "full_consumer", + "hashlib", + "json", + "pathlib", + "reference", + "serialization_controls", + "sys", + "types" + ], + "serialization_controls.py": [ + "__future__", + "bounded_serialization", + "copy", + "hashlib", + "json", + "pathlib", + "sys", + "types" + ], + "validate_outputs.py": [ + "__future__", + "argparse", + "gzip", + "hashlib", + "json", + "os", + "pathlib", + "stat", + "sys" + ] + }, + "input_source_pins": "../../serializer-o03-feasibility-20261031/technical/SOURCE-PINS-v1.json; three fixed authentic transport/logical identities also embedded independently in validator and loader", + "local_data_dependencies": [ + "CONTROL-SPEC.json", + "CONSUMER-CONTROL-SPEC-v1.json" + ], + "originals": [ + { + "bytes": 2141, + "copy": "reference.py", + "path": "../../independent-components-20261031/serializer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + { + "bytes": 23560, + "copy": "bounded_serialization.py", + "path": "../../independent-components-20261031/serializer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + { + "bytes": 23684, + "copy": "serialization_controls.py", + "path": "../../independent-components-20261031/serializer/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + { + "bytes": 3062, + "copy": "CONTROL-SPEC.json", + "path": "../../independent-components-20261031/serializer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + } + ], + "runtime_closure_owner": "../envelope/; actual interpreter/bootstrap/standard-library/native/shared-library/callable before-after seal required separately before execution", + "runtime_direct_dependencies_are_not_complete_transitive_seal": true, + "schema": "h25-o03-consumer-exact-dependencies-v1", + "scope": "Complete consumer source dependency declaration; combined runtime/input execution closure remains separately required" +} diff --git a/research/h25-authentic-serializer-20261031/consumer/PACKAGE-PINS-v1.json b/research/h25-authentic-serializer-20261031/consumer/PACKAGE-PINS-v1.json new file mode 100644 index 0000000000..e902ca311a --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/PACKAGE-PINS-v1.json @@ -0,0 +1,73 @@ +{ + "created_utc": "2026-10-31T08:11:27.417843+00:00", + "files": { + "CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "mode_octal": "0o444", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + "CONTROL-SPEC.json": { + "bytes": 3062, + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "DEPENDENCIES-v1.json": { + "bytes": 3934, + "mode_octal": "0o444", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + "PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "mode_octal": "0o444", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + "PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "mode_octal": "0o444", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + "README-v1.md": { + "bytes": 6609, + "mode_octal": "0o444", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + "SOURCE-READINESS-v1.json": { + "bytes": 2081, + "mode_octal": "0o444", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + "bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "full_consumer.py": { + "bytes": 9411, + "mode_octal": "0o444", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + "reference.py": { + "bytes": 2141, + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "run_controls.py": { + "bytes": 6630, + "mode_octal": "0o444", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + "serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "validate_outputs.py": { + "bytes": 14577, + "mode_octal": "0o444", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + } + }, + "manifest_self_excluded": true, + "schema": "h25-o03-consumer-package-pins-v1", + "scope": "Exact frozen authored I2 packet; no target execution or runtime admission" +} diff --git a/research/h25-authentic-serializer-20261031/consumer/PASSIVE-ATTEMPTS-v1.json b/research/h25-authentic-serializer-20261031/consumer/PASSIVE-ATTEMPTS-v1.json new file mode 100644 index 0000000000..c8d59bad78 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/PASSIVE-ATTEMPTS-v1.json @@ -0,0 +1,20 @@ +{ + "attempts": [ + { + "operation": "Initial named source read", + "outcome": "AUTHORIZATION-v1.json absent at stream root; corrected to control/AUTHORIZATION-v1.json", + "target_work": false + }, + { + "operation": "Pre-freeze independent source feedback", + "outcome": "Whole stat_result comparison could include access time; replaced with explicit identity excluding atime before freeze", + "target_work": false + }, + { + "operation": "Passive syntax/hash/copy checks", + "outcome": "All source parsed; exact four original copies; validator canonical literal AST equals original", + "target_work": false + } + ], + "schema": "h25-o03-consumer-passive-attempts-v1" +} diff --git a/research/h25-authentic-serializer-20261031/consumer/PASSIVE-CHECKS-v1.json b/research/h25-authentic-serializer-20261031/consumer/PASSIVE-CHECKS-v1.json new file mode 100644 index 0000000000..6a2e816cf9 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/PASSIVE-CHECKS-v1.json @@ -0,0 +1,109 @@ +{ + "controls_tests": 0, + "independent_validator_canonical_literal_ast_equal": true, + "note": "AST syntax/hash/source equality only; no runtime or scientific evidence", + "payload_decode_decompress": 0, + "schema": "h25-o03-consumer-passive-checks-v1", + "scientific_native_compiler": 0, + "source_ast": [ + { + "ast": "PARSED_ONLY_NO_EXECUTION", + "file": "bounded_serialization.py", + "imports": [ + "__future__", + "_json", + "contextlib", + "hashlib", + "json", + "json.encoder", + "os", + "pathlib", + "stat", + "tempfile", + "types" + ], + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + { + "ast": "PARSED_ONLY_NO_EXECUTION", + "file": "full_consumer.py", + "imports": [ + "__future__", + "argparse", + "bounded_serialization", + "frozen_h25_inputs", + "hashlib", + "json", + "os", + "pathlib", + "reference", + "stat", + "sys", + "time" + ], + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + { + "ast": "PARSED_ONLY_NO_EXECUTION", + "file": "reference.py", + "imports": [ + "hashlib", + "json" + ], + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + { + "ast": "PARSED_ONLY_NO_EXECUTION", + "file": "run_controls.py", + "imports": [ + "__future__", + "argparse", + "bounded_serialization", + "copy", + "full_consumer", + "hashlib", + "json", + "pathlib", + "reference", + "serialization_controls", + "sys", + "types" + ], + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + { + "ast": "PARSED_ONLY_NO_EXECUTION", + "file": "serialization_controls.py", + "imports": [ + "__future__", + "bounded_serialization", + "copy", + "hashlib", + "json", + "pathlib", + "sys", + "types" + ], + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + { + "ast": "PARSED_ONLY_NO_EXECUTION", + "file": "validate_outputs.py", + "imports": [ + "__future__", + "argparse", + "gzip", + "hashlib", + "json", + "os", + "pathlib", + "stat", + "sys" + ], + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + } + ], + "target_calls": 0, + "target_imports": 0, + "unchanged_copies": 4 +} diff --git a/research/h25-authentic-serializer-20261031/consumer/README-v1.md b/research/h25-authentic-serializer-20261031/consumer/README-v1.md new file mode 100644 index 0000000000..8879b820a9 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/README-v1.md @@ -0,0 +1,27 @@ +# Authentic complete retained-value O03 consumer source + +This packet implements source checkpoint I2. It has not been imported, executed, tested, decompressed or benchmarked by its author. Parent admission and the independent loader, immutable source/input/runtime closure, serialized guard and inclusive observer are required before any execution. No original scientific caller, native arithmetic, compiler, new construction, cache or retention work is performed. + +The four files `reference.py`, `bounded_serialization.py`, `serialization_controls.py` and `CONTROL-SPEC.json` are byte-exact copies of the frozen independent-components serializer sources. The original five-field EXPECTED, canonical and write_scientific remain unchanged. The production consumer passes the original exact original functions and EXPECTED into unchanged make_writer; it never clones or replaces the genuine-data oracle. Finite new controls alone clone the original code into separate finite EXPECTED globals, matching the old control convention. + +The immutable staged package must contain sibling `consumer/` and `loader/` directories. All paths passed below are canonical absolute paths in the new admitted workspace; every output root and receipt/report must be fresh. Receipt/report parents exist and receipts are external to artifact roots. The envelope authenticates source/runtime closure before and after each command. The consumer explicitly adds only its own directory and sibling loader directory to the isolated interpreter's path. + +```text +/usr/bin/python3.12 -B -I consumer/run_controls.py --output-root NEW_CONTROL_ROOT --receipt NEW_CONTROL_RECEIPT +/usr/bin/python3.12 -B -I -O consumer/run_controls.py --output-root ANOTHER_CONTROL_ROOT --receipt ANOTHER_CONTROL_RECEIPT +/usr/bin/python3.12 -B -I consumer/full_consumer.py --arm baseline --input-root NEW_BASELINE_INPUT --custody-json BASELINE_CUSTODY --output-root NEW_BASELINE_OUTPUT --receipt NEW_BASELINE_RECEIPT +/usr/bin/python3.12 -B -I consumer/full_consumer.py --arm candidate --input-root NEW_CANDIDATE_INPUT --custody-json CANDIDATE_CUSTODY --output-root NEW_CANDIDATE_OUTPUT --receipt NEW_CANDIDATE_RECEIPT +/usr/bin/python3.12 -B -I consumer/validate_outputs.py --input-root NEW_VALIDATOR_INPUT --custody-json VALIDATOR_CUSTODY --baseline-root BASELINE_OUTPUT --candidate-root CANDIDATE_OUTPUT --baseline-receipt BASELINE_RECEIPT --candidate-receipt CANDIDATE_RECEIPT --report NEW_VALIDATION_REPORT +``` + +The loader API is `load_frozen_inputs(Path, custody_dict)` returning result, witness, ranks and input_receipt under named dictionary keys. `authenticate_inputs(Path, custody_dict)` supplies the paid after-writer transport-only authentication and explicitly grants no logical/schema PASS. Fresh independent input roots are required for each arm and validator. Custody is `h25-input-custody-v1` with canonical root, exact root and ancestor directory identities/mode0555, unique regular nlink1 files/mode0444 and exact fixed transport pins. The loader owns schema restoration and ordered loader controls. + +Each full arm requires optimization0 and all original EXPECTED hashes,527/58143622/2674272 output bytes,59959 rank events and252 distinct row tuples. Candidate credit requires faults false, BOUNDED_SERIALIZATION_PASS, phase complete, actual nonempty bounded batch counts,1MiB byte/copy limits,1024-row limit, exact per-artifact stage/hash/copy counters/digests and the four-step cleanup receipt. Fresh output directory contents must be exactly the three final files and the recorded private stage must be gone. Literal fallback is retained original behavior but cannot qualify the genuine bounded route. Any failure preserves all partial/private artifacts and an attempted bounded failure receipt; it does not retry, resize or repair. + +The separate validator imports no loader/consumer/reference/candidate module. It independently holds fixed pins, strict small JSON parsing and the literal original canonical function. It authenticates new immutable transport inputs, independently projects the original result from the authenticated5662-byte certificate, compares complete witness and rank logical bytes simultaneously against both final arms with <=1MiB chunks, independently parses the fixed2674272-byte rank trace for exact-int schema and59959/252 counts, verifies full original and candidate receipts/counters/cleanup, then reauthenticates all transports and metadata. The rank parse has a fixed input cap; Python rank objects add measured allocation beyond that byte cap. Original historical allocation aliases are not claimed. Final receipt contents are checked against this independently read data, not used as sole oracles. Exact runtime/source integrity remains an envelope requirement. + +The new ordered15 controls include real finite successful bool/float and ordered duplicate-rank writes, two real fallback operations rejected for bounded credit, and11 source-bound acceptance failures for changed markers/fault flags/phase/batch/limits/counters/digests/cleanup/stage. The unchanged70 cases run first in each declared normal/-O process. `CONSUMER-CONTROL-SPEC-v1.json` fixes new count/order, and `CONTROL-SPEC.json` fixes the old count/order. No executed control claim is made here. + +All setup and imports, loader allocation, unchanged eager baseline encodings, candidate factory/preflight/repeated bounds/batches/staging/copy/freshness, rank sets, local streaming reads, receipts, controls, independent validator, failures and cleanup are paid work inside the envelope's inclusive operation. Writer timestamps cover only the direct writer call; factory/input preparation/readbacks/receipts are additional included work. The full consumer adds a transport-only17022954-byte after-writer rehash per arm. The validator adds34045908 transport hash bytes,17022954 transport reread bytes,60823556 logical bytes,121635788 complete witness/rank output comparison bytes,1054 result bytes, bounded rank JSON parse and all metadata/receipt work. The candidate's original doubled staging/final I/O and hashing bill remains unchanged. No time, CPU, sampled simultaneous group RSS, true peak, gain or cap fit has been established. + +I2 source acceptance, dynamic controls, actual genuine bounded-path eligibility, complete output validation, source/runtime/input custody and measured resource evidence remain distinct. This source packet grants no execution admission, O03 completion, original caller qualification, historical cost closure or whole-goal credit. The final observer-write/parent-readback/publication tail remains OPEN_NOT_ZERO. diff --git a/research/h25-authentic-serializer-20261031/consumer/SOURCE-READINESS-v1.json b/research/h25-authentic-serializer-20261031/consumer/SOURCE-READINESS-v1.json new file mode 100644 index 0000000000..702c8ac557 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/SOURCE-READINESS-v1.json @@ -0,0 +1,61 @@ +{ + "benchmark_measurements": 0, + "controls_tests": 0, + "created_utc": "2026-10-31T08:11:27.417843+00:00", + "credit": { + "O03": false, + "historical_cost_gap_closed": false, + "original_caller": false, + "whole_goal_complete": false + }, + "declared_control_optimizations": [ + 0, + 1 + ], + "dependency_manifest": "DEPENDENCIES-v1.json", + "execution_admitted": false, + "faults_enabled_required": false, + "full_arm_optimizations": [ + 0 + ], + "genuine_bounded_marker_required": "BOUNDED_SERIALIZATION_PASS", + "genuine_outputs": { + "bytes": { + "rank_trace": 2674272, + "result": 527, + "witness": 58143622 + }, + "distinct_rank_row_tuples": 252, + "rank_events": 59959 + }, + "independent_source_acceptance": false, + "literal_fallback_qualifies": false, + "loader_dependency": { + "bytes": 14650, + "path": "../loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "network_PR_actions": 0, + "new_consumer_controls_per_mode": 15, + "original_controls_per_mode": 70, + "outside_tail": "OPEN_NOT_ZERO", + "passive_checks": "PASSIVE-CHECKS-v1.json", + "payload_decode_decompress": 0, + "protected_runs_access": 0, + "reference_candidate_expected_unchanged": true, + "remaining": [ + "Independent complete I2 review", + "Independent loader/observer/custody/runtime closure review", + "Parent exact immutable-stage and P0-P5 admission under existing budget", + "Paid normal/-O controls and fixed first complete arms", + "Independent actual output/cleanup validation and measured inclusive resource/cost disposition" + ], + "retained_attempts": "PASSIVE-ATTEMPTS-v1.json", + "schema": "h25-o03-consumer-source-readiness-v1", + "scientific_native_compiler": 0, + "scope": "I2 complete retained-value consumer, independent bounded validator, unchanged70 controls and15 new controls per optimization mode", + "source_packet_manifest": "PACKAGE-PINS-v1.json", + "status": "FROZEN_SOURCE_READY_FOR_INDEPENDENT_REVIEW_ONLY", + "target_calls": 0, + "target_imports": 0 +} diff --git a/research/h25-authentic-serializer-20261031/consumer/bounded_serialization.py b/research/h25-authentic-serializer-20261031/consumer/bounded_serialization.py new file mode 100644 index 0000000000..70c4587a67 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/bounded_serialization.py @@ -0,0 +1,502 @@ +"""Exact-schema JSON batches and validated regular-file publication. + +The unchanged writer is the fallback and independent oracle. No scientific +imports, process execution, compilation or work occurs at module import. +Only make_writer is the production entry point. _make_writer's fault parameter +exists for parent-owned finite controls, never for an admitted full caller. +""" +from __future__ import annotations + +from contextlib import contextmanager +import _json +import hashlib +import json +import json.encoder +import os +from pathlib import Path +import stat +import tempfile +from types import CodeType, FunctionType + + +_WITNESS_KEYS = ("active", "args", "code", "kind", "labels", "pieces", "support") +_CODE_KEYS = ("gates", "outputs", "roles", "sources") +_FILES = ("result.json", "witness.json", "rank-trace.json") +_PATH_TYPE = type(Path(".")) +_REJECTION = "Complete output, ordered witness, or rank trace changed from the frozen profile" +_UNSUPPORTED = object() + + +def _need(condition, message): + if not condition: + raise RuntimeError(message) + + +def _keys_are(mapping, keys): + # Never hash or compare an unadmitted key (including a str subclass). + return (type(mapping) is dict and + all(type(key) is str for key in mapping) and + len(mapping) == len(keys) and all(key in mapping for key in keys)) + + +def _bound(value, limit, ancestors, depth=0): + """Safe ASCII JSON upper bound; no user conversion/iteration/hash hooks.""" + kind = type(value) + if kind is int: + return int.bit_length(value) * 30103 // 100000 + 2 + if kind is str: + return 12 * len(value) + 2 + if value is None: + return 4 + if kind is bool: + return 5 + if kind is float: + return 32 + if kind not in (list, tuple, dict) or depth >= 32: + return _UNSUPPORTED + identity = id(value) + if identity in ancestors: + return _UNSUPPORTED + ancestors.add(identity) + try: + size = 2 + if kind is dict: + # Check before sorting/hashing/lookup; actual JSON sorts these keys. + if any(type(key) is not str for key in value): + return _UNSUPPORTED + for key, item in dict.items(value): + child = _bound(item, limit, ancestors, depth + 1) + if child is _UNSUPPORTED: + return child + size += 12 * len(key) + 2 + 2 + child + if size > limit: + return size + else: + for item in value: + child = _bound(item, limit, ancestors, depth + 1) + if child is _UNSUPPORTED: + return child + size += 1 + child + if size > limit: + return size + return size + finally: + ancestors.remove(identity) + + +def _array_admitted(value, limit): + if type(value) not in (list, tuple): + return False + for item in value: + size = _bound(item, limit, set()) + # Include batch brackets and a conservative comma allowance. + if size is _UNSUPPORTED or size + 3 > limit: + return False + return True + + +def _admitted(result, witness, rank_calls, limit): + result_bound = _bound(result, limit, set()) + if result_bound is _UNSUPPORTED or result_bound > limit: + return False + if not _keys_are(witness, _WITNESS_KEYS): + return False + code = witness["code"] + if not _keys_are(code, _CODE_KEYS) or type(code["roles"]) is not int: + return False + if _bound(code["roles"], limit, set()) > limit: + return False + for key in _WITNESS_KEYS: + if key != "code" and not _array_admitted(witness[key], limit): + return False + for key in _CODE_KEYS: + if key != "roles" and not _array_admitted(code[key], limit): + return False + if type(rank_calls) is not list: + return False + for event in rank_calls: + if (type(event) is not tuple or len(event) != 2 or + type(event[0]) is not tuple or type(event[1]) is not int or + any(type(row) is not int for row in event[0])): + return False + return _array_admitted(rank_calls, limit) + + +def _regular_destination(output): + """Unsupported paths retain original behavior without candidate writes.""" + if type(output) is not _PATH_TYPE: + return False + try: + if not stat.S_ISDIR(output.lstat().st_mode): + return False + for name in _FILES: + try: + mode = (output / name).lstat().st_mode + except FileNotFoundError: + continue + if not stat.S_ISREG(mode): + return False + except OSError: + return False + return True + + +def _identity(info): + return (info.st_dev, info.st_ino, info.st_mode, info.st_size, + info.st_mtime_ns, info.st_ctime_ns) + + +def _freshness(reference_writer, reference_canonical, require): + """Capture closure-free references and effective JSON globals/builtins. + + The source-reviewed originals have no closure/default state. JSON function + dependencies include nested code objects (notably iterencode.floatstr). + Each absent global is checked for new shadowing as well as builtin drift. + """ + references = (reference_writer, reference_canonical, require) + _need(all(type(function) is FunctionType and function.__closure__ is None and + function.__defaults__ is None and function.__kwdefaults__ is None + for function in references), "Unexpected serializer reference function shape") + encoder = json.encoder + bindings = ( + (json, "dumps", json.dumps), + (json, "JSONEncoder", json.JSONEncoder), + (json, "encoder", encoder), + (encoder, "JSONEncoder", encoder.JSONEncoder), + (encoder, "c_make_encoder", encoder.c_make_encoder), + (encoder, "encode_basestring_ascii", encoder.encode_basestring_ascii), + (_json, "make_encoder", _json.make_encoder), + (_json, "encode_basestring_ascii", _json.encode_basestring_ascii), + (hashlib, "sha256", hashlib.sha256), + (json.JSONEncoder, "__init__", json.JSONEncoder.__init__), + (json.JSONEncoder, "encode", json.JSONEncoder.encode), + (json.JSONEncoder, "iterencode", json.JSONEncoder.iterencode), + (json.JSONEncoder, "default", json.JSONEncoder.default), + ) + _need(encoder.c_make_encoder is not None, "C JSON encoder unavailable") + binding_maps = tuple((vars(owner), name, entry) for owner, name, entry in bindings) + functions = [] + slots = [] + absent = object() + for function in references + (json.dumps, json.JSONEncoder.__init__, + json.JSONEncoder.encode, json.JSONEncoder.iterencode, + json.JSONEncoder.default): + _need(type(function) is FunctionType and function.__closure__ is None, + "Unexpected JSON function shape") + defaults = function.__defaults__ + keywords = function.__kwdefaults__ + _need(defaults is None or (type(defaults) is tuple and + all(type(item) in (str, int, float, bool, type(None)) for item in defaults)), + "Unsupported JSON default state") + _need(keywords is None or (type(keywords) is dict and + all(type(key) is str and type(value) in (str, int, float, bool, type(None)) + for key, value in keywords.items())), "Unsupported JSON keyword state") + keyword_items = None if keywords is None else tuple(keywords.items()) + namespace, effective_builtins = function.__globals__, function.__builtins__ + _need(type(namespace) is dict and type(effective_builtins) is dict, + "Unexpected effective serializer namespace") + functions.append((function, function.__code__, defaults, keywords, + keyword_items, namespace, effective_builtins)) + names = set() + pending = [function.__code__] + while pending: + code = pending.pop() + names.update(code.co_names) + pending.extend(item for item in code.co_consts if type(item) is CodeType) + for name in names: + slots.append((namespace, name, dict.get(namespace, name, absent), + effective_builtins, dict.get(effective_builtins, name, absent))) + encoder_class_map = vars(json.JSONEncoder) + encoder_class_items = tuple(encoder_class_map.items()) + + bound_len, bound_type, bound_all = len, type, all + bound_get, bound_dict, bound_error = dict.get, dict, RuntimeError + + def check_need(condition, message): + if not condition: + raise bound_error(message) + + def check(): + for namespace, name, entry in binding_maps: + check_need(namespace.get(name, absent) is entry, "JSON encoder binding changed: " + name) + check_need(bound_len(encoder_class_map) == bound_len(encoder_class_items) and + bound_all(encoder_class_map.get(name, absent) is entry + for name, entry in encoder_class_items), "JSON encoder class changed") + for function, code, defaults, keywords, keyword_items, namespace, builtins in functions: + check_need(function.__code__ is code and function.__defaults__ is defaults and + function.__kwdefaults__ is keywords and function.__closure__ is None and + function.__globals__ is namespace and function.__builtins__ is builtins, + "Serializer reference function changed") + if keywords is not None: + check_need(bound_type(keywords) is bound_dict and bound_len(keywords) == bound_len(keyword_items) and + bound_all(bound_type(key) is str for key in keywords) and + bound_all(bound_get(keywords, key, absent) is value for key, value in keyword_items), + "JSON keyword default changed") + for namespace, name, entry, builtins, builtin_entry in slots: + check_need(bound_get(namespace, name, absent) is entry and + bound_get(builtins, name, absent) is builtin_entry, + "Serializer effective global/builtin changed: " + name) + return check, bindings + + +def make_writer(reference_write_scientific, reference_canonical, expected, require, + *, batch_bytes=1048576, batch_rows=1024, copy_bytes=1048576): + return _make_writer(reference_write_scientific, reference_canonical, expected, require, + batch_bytes=batch_bytes, batch_rows=batch_rows, + copy_bytes=copy_bytes) + + +def _make_writer(reference_write_scientific, reference_canonical, expected, require, + *, batch_bytes=1048576, batch_rows=1024, copy_bytes=1048576, + fault=None): + """fault(event, info) -> NotImplemented or injected operation return. + + Private test seam: only parent finite controls pass fault. It can raise or + replace an IO result. Production make_writer cannot receive this argument. + """ + _need(type(batch_bytes) is int and 64 <= batch_bytes <= 1048576 and + type(batch_rows) is int and 1 <= batch_rows <= 1024 and + type(copy_bytes) is int and 1 <= copy_bytes <= 1048576, + "Invalid bounded serializer limits") + _need(type(expected) is dict and + all(type(key) is str and type(value) in (str, int) + for key, value in expected.items()), "Unexpected expected receipt") + expected_copy = dict(expected) + freshness, bindings = _freshness(reference_write_scientific, reference_canonical, require) + canonical = reference_canonical + + def expected_unchanged(): + _need(type(expected) is dict and + all(type(key) is str and type(value) in (str, int) + for key, value in expected.items()) and expected == expected_copy, + "Expected serializer receipt changed") + + def operation(event, action, **information): + if fault is not None: + injected = fault(event, information) + if injected is not NotImplemented: + return injected + return action() + + def full_write(stream, raw, phase, path): + view = memoryview(raw) + written = operation(phase + "_write", lambda: stream.write(view), + stream=stream, data=view, path=path) + if type(written) is not int or written != len(view): + raise OSError("Short " + phase + " write; no retry") + + def arrays(values, emit, info): + emit(b"[") + position = 0 + first = True + while position < len(values): + stop = position + bound = 2 + while stop < len(values) and stop - position < batch_rows: + item_bound = _bound(values[stop], batch_bytes, set()) + _need(item_bound is not _UNSUPPORTED and item_bound + 3 <= batch_bytes, + "Admitted serializer input changed") + if stop > position and bound + item_bound + 1 > batch_bytes: + break + bound += item_bound + 1 + stop += 1 + batch = values[position:stop] + raw = canonical(batch) + _need(len(raw) <= batch_bytes and raw[:1] == b"[" and raw[-1:] == b"]", + "Canonical batch violated bound or framing") + info["batch_count"] += 1 + info["largest_batch_bytes"] = max(info["largest_batch_bytes"], len(raw)) + if not first: + emit(b",") + emit(memoryview(raw)[1:-1]) + first = False + position = stop + emit(b"]") + + def witness_bytes(witness, emit, info): + emit(b"{") + for index, key in enumerate(_WITNESS_KEYS): + if index: + emit(b",") + emit(canonical(key)) + emit(b":") + if key != "code": + arrays(witness[key], emit, info) + continue + emit(b"{") + for code_index, code_key in enumerate(_CODE_KEYS): + if code_index: + emit(b",") + emit(canonical(code_key)) + emit(b":") + if code_key == "roles": + emit(canonical(witness["code"][code_key])) + else: + arrays(witness["code"][code_key], emit, info) + emit(b"}") + emit(b"}") + + def writer(output, result, witness, rank_calls): + freshness() + expected_unchanged() + if not _admitted(result, witness, rank_calls, batch_bytes) or not _regular_destination(output): + writer.last_operation = {"status": "LITERAL_REFERENCE_FALLBACK"} + answer = reference_write_scientific(output, result, witness, rank_calls) + try: + freshness() + expected_unchanged() + except BaseException: + writer.last_operation["status"] = "FALLBACK_EXIT_FRESHNESS_FAILED" + raise + return answer + info = {"status": "IN_PROGRESS", "phase": "stage_create", "stage": None, + "batch_count": 0, "largest_batch_bytes": 0, + "batch_bytes_limit": batch_bytes, "batch_rows_limit": batch_rows, + "copy_bytes_limit": copy_bytes, "files": {}, "cleanup": []} + writer.last_operation = info + stage = None + accepted = {} + + @contextmanager + def managed(stream, phase, path): + primary = None + try: + yield stream + except BaseException as error: + primary = error + raise + finally: + try: + stream.close() + operation(phase + "_after_close", lambda: None, path=path) + except BaseException as close_error: + if primary is None: + raise + info.setdefault("close_errors", []).append({ + "phase": phase, "type": type(close_error).__name__}) + try: + stage = Path(operation("stage_create", lambda: tempfile.mkdtemp( + prefix=".serialization-", dir=output), output=output)) + info["stage"] = str(stage) + for name, value in zip(_FILES, (result, witness, rank_calls)): + path = stage / name + info["phase"] = "stage:" + name + row = {"hashed_bytes": 0, "accepted_write_bytes": 0, + "copy_read_bytes": 0, "copy_write_bytes": 0} + info["files"][name] = row + hasher = hashlib.sha256() + stream = operation("stage_open", lambda: path.open("xb"), path=path) + with managed(stream, "stage", path): + def emit(raw): + operation("stage_hash", lambda: hasher.update(raw), path=path, data=raw) + row["hashed_bytes"] += len(raw) + full_write(stream, raw, "stage", path) + row["accepted_write_bytes"] += len(raw) + if name == "result.json": + emit(canonical(value)) + elif name == "witness.json": + witness_bytes(value, emit, info) + else: + arrays(value, emit, info) + operation("stage_flush", stream.flush, path=path, stream=stream) + facts = os.fstat(stream.fileno()) + _need(stat.S_ISREG(facts.st_mode) and + facts.st_size == row["accepted_write_bytes"], + "Staged artifact is not the complete regular file") + operation("stage_before_close", lambda: None, path=path, stream=stream) + _need(_identity(path.lstat()) == _identity(facts), "Staged artifact identity changed") + accepted[name] = (_identity(facts), hasher.hexdigest(), row["accepted_write_bytes"]) + row["sha256"] = accepted[name][1] + receipt = { + "result_sha256": accepted["result.json"][1], + "exact_witness_sha256": accepted["witness.json"][1], + "rank_trace_sha256": accepted["rank-trace.json"][1], + "rank_call_count": len(rank_calls), + "rank_distinct_matrix_count": len({rows for rows, _ in rank_calls}), + } + info["phase"] = "expected_receipt" + require(receipt == expected_copy, _REJECTION) + operation("after_acceptance", lambda: None, stage=stage, output=output) + for name in _FILES: + source, target = stage / name, output / name + identity, expected_digest, expected_size = accepted[name] + row = info["files"][name] + info["phase"] = "copy:" + name + _need(_identity(source.lstat()) == identity, "Staged artifact changed before copy") + copied_hash = hashlib.sha256() + incoming = operation("copy_open", lambda: source.open("rb"), path=source) + with managed(incoming, "copy", source): + _need(_identity(os.fstat(incoming.fileno())) == identity and + _identity(source.lstat()) == identity, "Staged read identity changed") + outgoing = operation("final_open", lambda: target.open("wb"), path=target) + with managed(outgoing, "final", target): + _need(stat.S_ISREG(os.fstat(outgoing.fileno()).st_mode), + "Final serializer sink is not a regular file") + while True: + raw = operation("copy_read", lambda: incoming.read(copy_bytes), + path=source, stream=incoming) + _need(type(raw) is bytes and len(raw) <= copy_bytes, + "Invalid bounded staged read") + if not raw: + break + row["copy_read_bytes"] += len(raw) + _need(row["copy_read_bytes"] <= expected_size, "Staged artifact grew during copy") + operation("copy_hash", lambda: copied_hash.update(raw), path=source, data=raw) + full_write(outgoing, raw, "final", target) + row["copy_write_bytes"] += len(raw) + operation("final_flush", outgoing.flush, path=target, stream=outgoing) + _need(os.fstat(outgoing.fileno()).st_size == expected_size, + "Final artifact byte count changed") + operation("final_before_close", lambda: None, path=target, stream=outgoing) + _need(_identity(os.fstat(incoming.fileno())) == identity, + "Staged artifact changed during copy") + _need(_identity(source.lstat()) == identity, + "Staged artifact path changed during copy") + _need(row["copy_read_bytes"] == expected_size and + row["copy_write_bytes"] == expected_size and + copied_hash.hexdigest() == expected_digest, + "Staged copy digest or byte count changed") + row["copy_sha256"] = copied_hash.hexdigest() + info["phase"] = "precleanup_freshness" + freshness() + expected_unchanged() + info["phase"] = "cleanup" + for name in _FILES: + path = stage / name + operation("cleanup_unlink", path.unlink, path=path) + info["cleanup"].append(name) + operation("cleanup_rmdir", stage.rmdir, path=stage) + info["cleanup"].append("stage_directory") + receipt["serialized_bytes"] = { + "result": accepted["result.json"][2], + "witness": accepted["witness.json"][2], + "rank_trace": accepted["rank-trace.json"][2], + } + info["phase"] = "exit_freshness" + freshness() + expected_unchanged() + info["phase"] = "complete" + info["status"] = "BOUNDED_SERIALIZATION_PASS" + return receipt + except BaseException as error: + info["status"] = "FAILED_EVIDENCE_RETAINED" + # Logging failures must never replace the primary exception. + try: + info["error"] = {"type": type(error).__name__, "message": str(error)[:2048]} + if stage is not None: + for name, row in info["files"].items(): + try: + row["retained_stage_stat_bytes"] = (stage / name).lstat().st_size + except OSError: + row["retained_stage_stat_bytes"] = None + raw = canonical(info) + _need(len(raw) <= 65536, "Serialization failure manifest exceeded bound") + operation("failure_manifest", lambda: (stage / "failure.json").write_bytes(raw), path=stage) + except BaseException as secondary: + info["failure_manifest_error_type"] = type(secondary).__name__ + raise + + writer.last_operation = None + writer._h25_serialization_bindings = bindings + writer._h25_serialization_faults_enabled = fault is not None + return writer diff --git a/research/h25-authentic-serializer-20261031/consumer/full_consumer.py b/research/h25-authentic-serializer-20261031/consumer/full_consumer.py new file mode 100644 index 0000000000..f1ee209194 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/full_consumer.py @@ -0,0 +1,176 @@ +"""Authentic retained-value serializer arm. Execute only after parent admission. + +Explicit sibling imports support python -B -I. The envelope authenticates these +exact source directories before and after execution. No scientific imports. +""" +from __future__ import annotations +import argparse +import hashlib +import json +import os +from pathlib import Path +import stat +import sys +import time + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +sys.path.insert(1, str(HERE.parent / 'loader')) +import reference + +NAMES = ('result.json', 'witness.json', 'rank-trace.json') +SIZE_KEYS = ('result', 'witness', 'rank_trace') +HASH_KEYS = ('result_sha256', 'exact_witness_sha256', 'rank_trace_sha256') +SIZES = dict(zip(SIZE_KEYS, (527, 58143622, 2674272))) +CHUNK = 1048576 + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def exact_int(value, low=0, high=None): + return type(value) is int and value >= low and (high is None or value <= high) + + +def accept_operation(operation, sizes, faults_enabled): + """Require complete source-bound bounded path; fallback never earns credit.""" + need(faults_enabled is False, 'Production fault seam enabled') + need(type(operation) is dict and operation.get('status') == 'BOUNDED_SERIALIZATION_PASS', + 'Genuine complete replay did not take bounded serializer path') + need(operation.get('phase') == 'complete', 'Bounded serialization incomplete') + need(operation.get('batch_bytes_limit') == CHUNK and type(operation.get('batch_bytes_limit')) is int, + 'Batch-byte limit differs') + need(operation.get('batch_rows_limit') == 1024 and type(operation.get('batch_rows_limit')) is int, + 'Batch-row limit differs') + need(operation.get('copy_bytes_limit') == CHUNK and type(operation.get('copy_bytes_limit')) is int, + 'Copy limit differs') + need(exact_int(operation.get('batch_count'), 1), 'Missing actual bounded batches') + need(exact_int(operation.get('largest_batch_bytes'), 2, CHUNK), 'Batch size differs') + need(operation.get('cleanup') == list(NAMES) + ['stage_directory'], 'Success cleanup incomplete') + need(type(operation.get('stage')) is str, 'Missing private stage identity') + need(set(operation.get('files', {})) == set(NAMES), 'Bounded file counters incomplete') + for name, key in zip(NAMES, SIZE_KEYS): + row = operation['files'][name] + need(type(row) is dict, 'Malformed bounded file counters') + need(all(exact_int(row.get(field)) and row[field] == sizes[key] for field in + ('hashed_bytes', 'accepted_write_bytes', 'copy_read_bytes', 'copy_write_bytes')), + 'Bounded copy/hash counters differ: ' + name) + need(type(row.get('sha256')) is str and row['sha256'] == row.get('copy_sha256'), + 'Private/final digest differs: ' + name) + + +def file_identity(info): + # Access time may legitimately change during readback under relatime. + return (info.st_dev, info.st_ino, info.st_mode, info.st_size, info.st_mtime_ns, + info.st_ctime_ns, info.st_nlink, info.st_uid, info.st_gid) + + +def read_files(root, scientific, expected, sizes): + need(set(path.name for path in root.iterdir()) == set(NAMES), 'Unexpected output or staging files') + files = {} + for name, key, size_key in zip(NAMES, HASH_KEYS, SIZE_KEYS): + path = root / name + before = path.lstat() + need(stat.S_ISREG(before.st_mode) and before.st_nlink == 1, 'Output is not private regular file') + h, total = hashlib.sha256(), 0 + fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW) + with os.fdopen(fd, 'rb') as stream: + need(file_identity(os.fstat(stream.fileno())) == file_identity(before), 'Output descriptor/path differs') + while True: + chunk = stream.read(CHUNK) + if not chunk: + break + total += len(chunk) + need(total <= sizes[size_key], 'Output exceeds frozen size') + h.update(chunk) + need(file_identity(os.fstat(stream.fileno())) == file_identity(before), 'Output changed while reading') + need(file_identity(path.lstat()) == file_identity(before), 'Output path changed while reading') + need(total == sizes[size_key] == scientific['serialized_bytes'][size_key], 'Output size differs') + need(h.hexdigest() == expected[key] == scientific[key], 'Output digest differs') + files[name] = {'bytes': total, 'sha256': h.hexdigest()} + return files + + +def write_record(path, value): + raw = json.dumps(value, sort_keys=True, indent=2, allow_nan=False).encode('ascii') + b'\n' + need(len(raw) <= 65536, 'Consumer receipt exceeds fixed bound') + with path.open('xb') as stream: + need(stream.write(raw) == len(raw), 'Short consumer receipt write') + + +def run(arm, input_root, custody, output_root, receipt_path): + need(arm in ('baseline', 'candidate'), 'Unknown serializer arm') + need(sys.flags.optimize == 0, 'Full arm requires optimization0') + need(not output_root.exists() and not output_root.is_symlink(), 'Output root must be fresh') + need(not receipt_path.exists() and not receipt_path.is_symlink(), 'Receipt must be fresh') + need(receipt_path.parent.resolve() != output_root.resolve(), 'Receipt must be outside artifact root') + from frozen_h25_inputs import load_frozen_inputs + loaded = load_frozen_inputs(input_root, custody) + result, witness, ranks = loaded['result'], loaded['witness'], loaded['ranks'] + need(len(ranks) == reference.EXPECTED['rank_call_count'], 'Full rank count differs') + need(len({rows for rows, _ in ranks}) == reference.EXPECTED['rank_distinct_matrix_count'], + 'Full distinct rank row count differs') + output_root.mkdir(mode=0o700) + writer = reference.write_scientific + faults = None + if arm == 'candidate': + import bounded_serialization + writer = bounded_serialization.make_writer(reference.write_scientific, reference.canonical, + reference.EXPECTED, reference.require, batch_bytes=CHUNK, batch_rows=1024, copy_bytes=CHUNK) + faults = writer._h25_serialization_faults_enabled + need(faults is False, 'Fault injection enabled') + started = time.monotonic_ns() + scientific = writer(output_root, result, witness, ranks) + ended = time.monotonic_ns() + need(scientific == dict(reference.EXPECTED, serialized_bytes=SIZES), 'Original complete receipt differs') + operation = None if arm == 'baseline' else writer.last_operation + if arm == 'candidate': + accept_operation(operation, SIZES, faults) + stage = Path(operation['stage']) + need(stage.parent == output_root and stage.name.startswith('.serialization-') and + not stage.exists() and not stage.is_symlink(), 'Private stage cleanup differs') + need(operation['batch_count'] <= len(ranks) + sum(len(witness[k]) for k in witness if k != 'code') + + sum(len(v) for k, v in witness['code'].items() if k != 'roles'), 'Impossible batch count') + for name, digest_key in zip(NAMES, HASH_KEYS): + need(operation['files'][name]['sha256'] == reference.EXPECTED[digest_key], 'Bounded digest differs') + files = read_files(output_root, scientific, reference.EXPECTED, SIZES) + # Complete second authentication is paid and must not allocate another full input. + from frozen_h25_inputs import authenticate_inputs + after = authenticate_inputs(input_root, custody) + receipt = {'schema': 'h25-o03-full-consumer-v1', 'status': 'COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED', + 'arm': arm, 'optimization': sys.flags.optimize, 'scientific_receipt': scientific, + 'files': files, 'candidate_operation': operation, 'faults_enabled': faults, + 'input_receipt': loaded['input_receipt'], 'after_input_receipt': after, + 'writer_monotonic_ns': {'start': started, 'end': ended, 'elapsed': ended - started}, + 'scope': 'Complete authentic retained values; no fresh scientific construction or caller claim'} + write_record(receipt_path, receipt) + return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--arm', choices=('baseline', 'candidate'), required=True) + parser.add_argument('--input-root', type=Path, required=True) + parser.add_argument('--custody-json', type=Path, required=True) + parser.add_argument('--output-root', type=Path, required=True) + parser.add_argument('--receipt', type=Path, required=True) + args = parser.parse_args() + try: + custody = json.loads(args.custody_json.read_text(encoding='utf-8')) + result = run(args.arm, args.input_root, custody, args.output_root, args.receipt) + except BaseException as error: + # Preserve all partial final/private files. A failure is never rerolled. + if not args.receipt.exists() and not args.receipt.is_symlink(): + try: + write_record(args.receipt, {'schema': 'h25-o03-full-consumer-v1', 'status': 'FAILED_EVIDENCE_RETAINED', + 'arm': args.arm, 'error': {'type': type(error).__name__, 'message': str(error)[:2048]}}) + except BaseException: + pass + raise + print(json.dumps({'status': result['status'], 'arm': args.arm}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/consumer/reference.py b/research/h25-authentic-serializer-20261031/consumer/reference.py new file mode 100644 index 0000000000..2c60da3ae8 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/reference.py @@ -0,0 +1,47 @@ +"""Source-exact serializer reference extracted without importing scientific code. + +EXPECTED remains the frozen complete H25 receipt. Finite consumers clone only +write_scientific into fresh globals with a separate finite EXPECTED dictionary. +No full H25 construction, native backend, compiler or scientific caller is loaded. +""" +import hashlib +import json + + +_RUNTIME_ERROR = RuntimeError + +def require(condition, message): + if not condition: + raise _RUNTIME_ERROR(message) + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + +EXPECTED = { + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, +} + +def write_scientific(output, result, witness, rank_calls): + encoded_result = canonical(result) + encoded_witness = canonical(witness) + encoded_trace = canonical(rank_calls) + receipt = { + "result_sha256": hashlib.sha256(encoded_result).hexdigest(), + "exact_witness_sha256": hashlib.sha256(encoded_witness).hexdigest(), + "rank_trace_sha256": hashlib.sha256(encoded_trace).hexdigest(), + "rank_call_count": len(rank_calls), + "rank_distinct_matrix_count": len({rows for rows, _ in rank_calls}), + } + require(receipt == EXPECTED, "Complete output, ordered witness, or rank trace changed from the frozen profile") + # Same exact bytes and serialization work in both arms; file hashes omit + # a trailing newline exactly as the existing profile's digest did. + (output / "result.json").write_bytes(encoded_result) + (output / "witness.json").write_bytes(encoded_witness) + (output / "rank-trace.json").write_bytes(encoded_trace) + receipt["serialized_bytes"] = {"result": len(encoded_result), "witness": len(encoded_witness), + "rank_trace": len(encoded_trace)} + return receipt diff --git a/research/h25-authentic-serializer-20261031/consumer/run_controls.py b/research/h25-authentic-serializer-20261031/consumer/run_controls.py new file mode 100644 index 0000000000..1926eb081f --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/run_controls.py @@ -0,0 +1,138 @@ +"""Ordered unchanged70 plus concrete consumer acceptance controls; parent only.""" +from __future__ import annotations +import argparse +import copy +import hashlib +import json +from pathlib import Path +import sys +from types import FunctionType + +HERE = Path(__file__).resolve().parent +sys.path.insert(0, str(HERE)) +import reference +import bounded_serialization +import serialization_controls +from full_consumer import accept_operation, need, write_record + +ORDER = ['legitimate-bool-float-slots', 'ordered-duplicate-ranks', 'literal-fallback-no-credit', + 'int-only-rank-bool-fallback-no-credit', 'missing-marker-no-credit', 'faults-enabled-no-credit', + 'incomplete-phase-no-credit', 'missing-batches-no-credit', 'oversize-batch-no-credit', + 'wrong-copy-limit-no-credit', 'missing-file-counter-no-credit', 'wrong-byte-counter-no-credit', + 'digest-copy-mismatch-no-credit', 'incomplete-cleanup-no-credit', 'missing-stage-no-credit'] + + +def finite_writer(values): + result, witness, ranks = values + expected = {'result_sha256': hashlib.sha256(reference.canonical(result)).hexdigest(), + 'exact_witness_sha256': hashlib.sha256(reference.canonical(witness)).hexdigest(), + 'rank_trace_sha256': hashlib.sha256(reference.canonical(ranks)).hexdigest(), + 'rank_call_count': len(ranks), 'rank_distinct_matrix_count': len({row for row, _ in ranks})} + namespace = dict(reference.write_scientific.__globals__) + namespace['EXPECTED'] = expected + original = FunctionType(reference.write_scientific.__code__, namespace, + reference.write_scientific.__name__, reference.write_scientific.__defaults__, + reference.write_scientific.__closure__) + return bounded_serialization.make_writer(original, reference.canonical, expected, reference.require) + + +def run(root, receipt_path): + need(sys.flags.optimize in (0, 1), 'Undeclared control optimization') + need(not root.exists() and not root.is_symlink(), 'Control root must be fresh') + need(not receipt_path.exists() and not receipt_path.is_symlink(), 'Control receipt must be fresh') + root.mkdir(mode=0o700) + spec = json.loads((HERE / 'CONTROL-SPEC.json').read_text(encoding='utf-8')) + old = serialization_controls.run_controls(reference, root / 'original70') + need(old['case_count'] == spec['count_per_mode'] == 70, 'Original control count differs') + need([row['case'] for row in old['cases']] == spec['ordered_cases'], 'Original control order differs') + need(old['optimization'] == sys.flags.optimize, 'Original control optimization differs') + rows = [] + + def fresh(): + return serialization_controls._fixture()[:3] + + def actual(name, transform, bounded): + result, witness, ranks = fresh() + values = transform(result, witness, ranks) + writer = finite_writer(values) + output = root / name + output.mkdir() + receipt = writer(output, *values) + if bounded: + accept_operation(writer.last_operation, receipt['serialized_bytes'], writer._h25_serialization_faults_enabled) + need(not list(output.glob('.serialization-*')), 'Successful bounded staging leaked') + else: + need(writer.last_operation['status'] == 'LITERAL_REFERENCE_FALLBACK', 'Literal fallback was not observed') + try: + accept_operation(writer.last_operation, receipt['serialized_bytes'], False) + except RuntimeError: + pass + else: + raise RuntimeError('Literal fallback incorrectly qualified as bounded') + rows.append({'case': name, 'status': 'PASS', 'operation': writer.last_operation}) + return writer.last_operation, receipt['serialized_bytes'] + + def floats(result, witness, ranks): + result.update({'bool_slot': True, 'roles_per_target': 47.041}) + return result, witness, ranks + operation, sizes = actual(ORDER[0], floats, True) + + def duplicates(result, witness, ranks): + ranks[:] = [((2, 1), 1), ((2, 1), 1), ((1, 2), 2)] + return result, witness, ranks + actual(ORDER[1], duplicates, True) + + def unsupported(result, witness, ranks): + class DictSubclass(dict): + pass + return DictSubclass(result), witness, ranks + actual(ORDER[2], unsupported, False) + + def rank_bool(result, witness, ranks): + ranks[0] = ((True, 2), 1) + return result, witness, ranks + actual(ORDER[3], rank_bool, False) + + mutations = [ + lambda op: op.update(status='LITERAL_REFERENCE_FALLBACK'), + lambda op: None, + lambda op: op.update(phase='copy:witness.json'), + lambda op: op.update(batch_count=0), + lambda op: op.update(largest_batch_bytes=1048577), + lambda op: op.update(copy_bytes_limit=1048577), + lambda op: op['files'].pop('witness.json'), + lambda op: op['files']['witness.json'].update(copy_write_bytes=0), + lambda op: op['files']['result.json'].update(copy_sha256='0' * 64), + lambda op: op.update(cleanup=['result.json']), + lambda op: op.pop('stage'), + ] + for name, mutation in zip(ORDER[4:], mutations): + changed = copy.deepcopy(operation) + mutation(changed) + try: + accept_operation(changed, sizes, name == 'faults-enabled-no-credit') + except RuntimeError as error: + rows.append({'case': name, 'status': 'PASS', 'expected_rejection': str(error)}) + else: + raise RuntimeError('Consumer accepted invalid bounded evidence: ' + name) + need([row['case'] for row in rows] == ORDER, 'New consumer control count/order differs') + receipt = {'schema': 'h25-o03-consumer-controls-v1', 'status': 'CONSUMER_CONTROLS_RETURNED', + 'optimization': sys.flags.optimize, 'old_case_count': 70, 'new_case_count': len(rows), + 'old_control_receipt': str(root / 'original70' / 'controls.json'), 'cases': rows, + 'scope': 'Finite controls only; authentic full replay is separately mandatory'} + write_record(receipt_path, receipt) + return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output-root', type=Path, required=True) + parser.add_argument('--receipt', type=Path, required=True) + args = parser.parse_args() + receipt = run(args.output_root, args.receipt) + print(json.dumps({'status': receipt['status'], 'optimization': receipt['optimization'], + 'old_cases': 70, 'new_cases': len(ORDER)}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/consumer/serialization_controls.py b/research/h25-authentic-serializer-20261031/consumer/serialization_controls.py new file mode 100644 index 0000000000..7ace093a93 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/serialization_controls.py @@ -0,0 +1,504 @@ +"""Parent-executed bounded controls; imports no scientific module itself.""" +from __future__ import annotations + +import copy +import hashlib +import json +from pathlib import Path +import sys +from types import FunctionType + +import bounded_serialization as candidate + + +_NAMES = ("result.json", "witness.json", "rank-trace.json") + + +def _need(value, message): + if not value: + raise RuntimeError(message) + + +def _fixture(): + return ({"ok": True, "number": 3}, { + "support": [0, 1, 3], "args": [None, (0, 1)], "kind": [None, "in"], + "active": [1, 2], "pieces": [((0, 1, 2), 2, (1, 2))], + "labels": [(1, [(2, 3), (0, 1)], 2, (1, 3))], + "code": {"roles": 3, "gates": [(1, (0,), (1, 2))], + "sources": [((2, 1, 0), 1), ((0, 1, 2), 2)], "outputs": [(1, 2), (0, 1)]}, + }, [((1, 2), 2), ((1, 2), 1), ((2,), 1)], []) + + +def _outcome(function): + try: + return ("return", function()) + except BaseException as error: + return ("error", type(error).__name__, str(error)) + + +def _original_writer(comparison, expected): + namespace = dict(comparison.write_scientific.__globals__) + namespace["EXPECTED"] = expected + # Same original code, separate globals; the imported comparison is untouched. + return FunctionType(comparison.write_scientific.__code__, namespace, + comparison.write_scientific.__name__, + comparison.write_scientific.__defaults__, + comparison.write_scientific.__closure__) + + +def _expected(comparison, fixture): + result, witness, ranks, _ = fixture + return { + "result_sha256": hashlib.sha256(comparison.canonical(result)).hexdigest(), + "exact_witness_sha256": hashlib.sha256(comparison.canonical(witness)).hexdigest(), + "rank_trace_sha256": hashlib.sha256(comparison.canonical(ranks)).hexdigest(), + "rank_call_count": len(ranks), + "rank_distinct_matrix_count": len({rows for rows, _ in ranks}), + } + + +def _finals(path): + return {name: (path / name).read_bytes() for name in _NAMES if (path / name).is_file()} + + +def run_controls(comparison, output_root): + """Run once in a new external directory under the parent's guard. + + comparison supplies the unchanged write_scientific/canonical/require. + No full caller, native build, scientific import or timer is started here. + """ + root = Path(output_root) + _need(not root.exists(), "Refusing existing serializer control evidence") + root.mkdir(parents=True) + rows = [] + original_source = comparison.write_scientific.__code__ + total_cap = 16777216 + base_expected = _expected(comparison, _fixture()) + + def equal(name, factory=_fixture, *, limits=None, expected_override=None, admitted=None): + before = factory() + after = factory() + _need(before[1] is not after[1] and before[2] is not after[2], "Shared control inputs") + try: + expected = _expected(comparison, factory()) + except BaseException: + expected = dict(base_expected) + if expected_override is not None: + expected_override(expected) + original = _original_writer(comparison, expected) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require, + **(limits or {})) + case = root / name + left, right = case / "original", case / "candidate" + left.mkdir(parents=True) + right.mkdir() + old = _outcome(lambda: original(left, *before[:3])) + new = _outcome(lambda: writer(right, *after[:3])) + _need(old == new, "Serializer outcome differs: " + name + " " + repr((old, new))) + _need(before[3] == after[3], "Callback count/order differs: " + name) + _need(_finals(left) == _finals(right), "Final artifact bytes differ: " + name) + if admitted is not None: + expected_status = "LITERAL_REFERENCE_FALLBACK" if not admitted else ( + "BOUNDED_SERIALIZATION_PASS" if new[0] == "return" else "FAILED_EVIDENCE_RETAINED") + _need(writer.last_operation["status"] == expected_status, "Admission differs: " + name) + if new[0] == "return" and writer.last_operation["status"] == "BOUNDED_SERIALIZATION_PASS": + _need(not tuple(right.glob(".serialization-*")), "Successful staging leaked") + for record in writer.last_operation["files"].values(): + _need(record["sha256"] == record["copy_sha256"] and + record["hashed_bytes"] == record["accepted_write_bytes"] == + record["copy_read_bytes"] == record["copy_write_bytes"], + "Copy verification/cost count differs") + rows.append({"case": name, "outcome": new[0], "operation": writer.last_operation}) + + equal("ordinary", admitted=True) + + def empty(): + result, witness, ranks, events = _fixture() + for key in witness: + if key == "code": + witness[key] = {"gates": [], "outputs": [], "roles": 0, "sources": []} + else: + witness[key] = [] + return result, witness, [], events + equal("empty", empty, admitted=True) + + for length in (1, 1023, 1024, 1025, 2048): + def length_case(length=length): + result, witness, ranks, events = _fixture() + witness["support"] = list(range(length)) + return result, witness, ranks, events + equal("rows-" + str(length), length_case, admitted=True) + + for length, expected_admitted in ((169, True), (170, True), (171, False)): + def size_case(length=length): + result, witness, ranks, events = _fixture() + witness["kind"] = ["a" * length, "z"] + return result, witness, ranks, events + equal("byte-bound-" + str(length), size_case, + limits={"batch_bytes": 2045, "batch_rows": 3, "copy_bytes": 127}, + admitted=expected_admitted) + + def scalar_case(): + result, witness, ranks, events = _fixture() + witness["kind"] = [None, True, False, 0.0, -0.0, 1.25, float("inf"), + -float("inf"), float("nan"), '\\"\b\f\n\r\t\x00', + "\u1234\U0001f642\ud800\udfff"] + witness["support"] = [0, -1, (1 << 53) - 1, 1 << 53, (1 << 64) - 1, + 1 << 64, -(1 << 64), 1 << 2300] + return result, witness, ranks, events + equal("scalars-unicode-wide", scalar_case, admitted=True) + + def huge(): + result, witness, ranks, events = _fixture() + witness["support"] = [1 << 20000, -(1 << 20000)] + return result, witness, ranks, events + old_digits = sys.get_int_max_str_digits() + try: + sys.set_int_max_str_digits(0) + equal("wide-unlimited", huge, admitted=True) + sys.set_int_max_str_digits(640) + equal("wide-digit-error", huge, admitted=True) + finally: + sys.set_int_max_str_digits(old_digits) + + def interned(): + result, witness, _, events = _fixture() + row = (1, 2, 3) + return result, witness, [(row, 2), (row, 1), (tuple([1, 2, 3]), 2)], events + equal("interned-rank-rows", interned, admitted=True) + + for depth in (30, 33): + def nested(depth=depth): + result, witness, ranks, events = _fixture() + value = 1 + for _ in range(depth): + value = [value] + witness["kind"] = [value] + return result, witness, ranks, events + equal("depth-" + str(depth), nested, admitted=depth == 30) + + def circular(): + result, witness, ranks, events = _fixture() + cycle = [] + cycle.append(cycle) + witness["kind"] = [cycle] + return result, witness, ranks, events + equal("circular", circular, admitted=False) + + def callback_list(): + result, witness, ranks, events = _fixture() + class Observed(list): + def __iter__(self): + events.append("list-iter") + return super().__iter__() + witness["kind"] = Observed(["in", "x"]) + return result, witness, ranks, events + equal("callback-list", callback_list, admitted=False) + + def callback_dict(): + result, witness, ranks, events = _fixture() + class Observed(dict): + def items(self): + events.append("dict-items") + return super().items() + result = Observed(result) + return result, witness, ranks, events + equal("callback-dict", callback_dict, admitted=False) + + def callback_raising(): + result, witness, ranks, events = _fixture() + class Observed(dict): + def items(self): + events.append("raising-items") + raise LookupError("observed conversion failure") + witness["kind"] = [Observed({"x": 1})] + return result, witness, ranks, events + equal("callback-error", callback_raising, admitted=False) + + def subclass_int(): + result, witness, ranks, events = _fixture() + class Observed(int): + def __repr__(self): + events.append("int-repr") + return "7" + witness["support"] = [Observed(7)] + return result, witness, ranks, events + equal("int-subclass", subclass_int, admitted=False) + + def unknown(): + result, witness, ranks, events = _fixture() + class Unknown: + pass + witness["kind"] = [Unknown()] + return result, witness, ranks, events + equal("unsupported-object", unknown, admitted=False) + + for location in ("result", "witness", "rank"): + def malformed(location=location): + result, witness, ranks, events = _fixture() + if location == "result": + result = {1: 1, "x": 2} + elif location == "witness": + witness["kind"] = [set([1])] + else: + ranks = [([1], 1)] + return result, witness, ranks, events + equal("malformed-" + location, malformed, admitted=False) + + def nonstring_keys(): + result, witness, ranks, events = _fixture() + result = {2: "b", 1: "a"} + return result, witness, ranks, events + equal("nonstring-supported-keys", nonstring_keys, admitted=False) + + for key in ("result_sha256", "exact_witness_sha256", "rank_trace_sha256", + "rank_call_count", "rank_distinct_matrix_count"): + def alter(expected, key=key): + expected[key] = "0" * 64 if type(expected[key]) is str else expected[key] + 1 + equal("expected-" + key, expected_override=alter, admitted=True) + + def fault_case(name, fault, expected_error, *, final_names=(), missing_final_names=(), + manifest_may_fail=False): + fixture = _fixture() + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + writer = candidate._make_writer(original, comparison.canonical, expected, comparison.require, + batch_bytes=2048, batch_rows=3, copy_bytes=31, fault=fault) + output = root / name + output.mkdir() + outcome = _outcome(lambda: writer(output, *fixture[:3])) + _need(outcome[0] == "error" and outcome[1] == expected_error, + "Fault did not surface: " + name + " " + repr(outcome)) + _need(writer.last_operation["status"] == "FAILED_EVIDENCE_RETAINED", "Fault hidden") + for filename in final_names: + _need((output / filename).exists(), "Earlier/failing final disappeared: " + name) + for filename in missing_final_names: + _need(not (output / filename).exists(), "Later/unaccepted final appeared: " + name) + if writer.last_operation["stage"] is not None: + stage = Path(writer.last_operation["stage"]) + _need(stage.is_dir(), "Failed staging evidence deleted") + if not manifest_may_fail: + _need((stage / "failure.json").is_file(), "Failure manifest missing") + rows.append({"case": name, "outcome": outcome, "operation": writer.last_operation}) + return writer.last_operation + + def raising(event_name, filename=None, error_type=OSError, text="injected IO failure"): + def fault(event, information): + path = information.get("path") + if event == event_name and (filename is None or (path is not None and path.name == filename)): + raise error_type(text) + return NotImplemented + return fault + + for event in ("stage_create", "stage_open", "stage_write", "stage_flush", "stage_after_close", "stage_hash"): + fault_case("failure-" + event, raising(event), "OSError", missing_final_names=_NAMES) + + for filename in _NAMES: + index = _NAMES.index(filename) + for event in ("final_open", "final_write", "final_flush", "final_after_close"): + present = _NAMES[:index] if event == "final_open" else _NAMES[:index + 1] + fault_case("failure-" + event + "-" + filename, raising(event, filename), "OSError", + final_names=present, missing_final_names=_NAMES[index + 1:]) + + for length in (0, 1): + def short(event, information, length=length): + if event == "final_write" and information["path"].name == "witness.json": + information["stream"].write(information["data"][:length]) + return length + return NotImplemented + fault_case("short-final-" + str(length), short, "OSError", + final_names=_NAMES[:2], missing_final_names=_NAMES[2:]) + + def corrupt(event, information): + if event == "copy_read" and information["path"].name == "witness.json": + raw = information["stream"].read(31) + if raw: + return bytes([raw[0] ^ 1]) + raw[1:] + return raw + return NotImplemented + fault_case("copy-corrupt-content", corrupt, "RuntimeError", + final_names=_NAMES[:2], missing_final_names=_NAMES[2:]) + + def mutate_stage(event, information): + if event == "after_acceptance": + with (information["stage"] / "witness.json").open("ab") as stream: + stream.write(b" ") + return NotImplemented + fault_case("stage-mutated-size", mutate_stage, "RuntimeError", + final_names=_NAMES[:1], missing_final_names=_NAMES[1:]) + fault_case("copy-read-error", raising("copy_read", "witness.json"), "OSError", + final_names=_NAMES[:2], missing_final_names=_NAMES[2:]) + fault_case("copy-hash-error", raising("copy_hash", "witness.json"), "OSError", + final_names=_NAMES[:2], missing_final_names=_NAMES[2:]) + fault_case("cleanup-unlink-error", raising("cleanup_unlink", "witness.json"), "OSError", + final_names=_NAMES) + fault_case("cleanup-rmdir-error", raising("cleanup_rmdir"), "OSError", final_names=_NAMES) + + def dual_error(event, information): + if event == "stage_write": + raise ValueError("primary write failure") + if event == "stage_after_close": + raise OSError("secondary close failure") + return NotImplemented + evidence = fault_case("primary-plus-close-error", dual_error, "ValueError", missing_final_names=_NAMES) + _need(evidence["error"]["message"] == "primary write failure" and evidence.get("close_errors"), + "Close failure masked primary error") + + def manifest_error(event, information): + if event == "stage_write": + raise ValueError("primary write failure") + if event == "failure_manifest": + raise OSError("secondary manifest failure") + return NotImplemented + evidence = fault_case("primary-plus-manifest-error", manifest_error, "ValueError", + missing_final_names=_NAMES, manifest_may_fail=True) + _need(evidence["failure_manifest_error_type"] == "OSError", "Manifest failure hidden") + + for name in ("reference_global", "json_default", "expected_value"): + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require) + output = root / ("drift-" + name) + output.mkdir() + saved_default = json.JSONEncoder.default + saved_canonical = original.__globals__["canonical"] + try: + if name == "reference_global": + original.__globals__["canonical"] = lambda value: b"wrong" + elif name == "json_default": + json.JSONEncoder.default = lambda self, value: "wrong" + else: + expected["rank_call_count"] += 1 + outcome = _outcome(lambda: writer(output, *_fixture()[:3])) + finally: + json.JSONEncoder.default = saved_default + original.__globals__["canonical"] = saved_canonical + _need(outcome[0:2] == ("error", "RuntimeError") and not tuple(output.iterdir()), + "Source/expected drift reached output") + rows.append({"case": "drift-" + name, "outcome": outcome}) + + # Effective builtin and previously absent global dependencies are part of + # the source-bound encoder, not merely public callable identities. + for name in ("effective_builtin", "json_global_shadow", "keyword_default"): + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + if name == "effective_builtin": + namespace = dict(original.__globals__) + namespace["__builtins__"] = dict(original.__builtins__) + original = FunctionType(original.__code__, namespace, original.__name__) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require) + output = root / ("drift-" + name) + output.mkdir() + saved_allow_nan = json.JSONEncoder.__init__.__kwdefaults__["allow_nan"] + _need("str" not in json.encoder.__dict__, "Unexpected JSON str shadow at test entry") + try: + if name == "effective_builtin": + original.__builtins__["len"] = lambda value: 0 + elif name == "json_global_shadow": + json.encoder.__dict__["str"] = object + else: + json.JSONEncoder.__init__.__kwdefaults__["allow_nan"] = False + outcome = _outcome(lambda: writer(output, *_fixture()[:3])) + finally: + json.encoder.__dict__.pop("str", None) + json.JSONEncoder.__init__.__kwdefaults__["allow_nan"] = saved_allow_nan + _need(outcome[0:2] == ("error", "RuntimeError") and not tuple(output.iterdir()), + "Effective JSON dependency drift reached output") + rows.append({"case": "drift-" + name, "outcome": outcome}) + + saved_default = json.JSONEncoder.default + def late_drift(event, information): + if event == "final_after_close" and information["path"].name == "rank-trace.json": + json.JSONEncoder.default = lambda self, value: "drift" + return NotImplemented + try: + fault_case("exit-json-drift", late_drift, "RuntimeError", final_names=_NAMES) + finally: + json.JSONEncoder.default = saved_default + + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require) + output = root / "fallback-exit-json-drift" + output.mkdir() + result, witness, ranks, events = _fixture() + class MutatingDict(dict): + def items(self): + events.append("dict-items") + json.JSONEncoder.default = lambda self, value: "drift" + return super().items() + try: + outcome = _outcome(lambda: writer(output, MutatingDict(result), witness, ranks)) + finally: + json.JSONEncoder.default = saved_default + _need(outcome[0:2] == ("error", "RuntimeError") and + writer.last_operation["status"] == "FALLBACK_EXIT_FRESHNESS_FAILED" and + all((output / name).is_file() for name in _NAMES), + "Fallback runtime drift escaped successful-exit guard") + rows.append({"case": "fallback-exit-json-drift", "outcome": outcome}) + + # Preserve direct-call overwrite behavior, separately from parent run-dir guard. + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require) + output = root / "existing-finals" + output.mkdir() + for name in _NAMES: + (output / name).write_bytes(b"previous bytes") + writer(output, *_fixture()[:3]) + old = root / "existing-finals-reference" + old.mkdir() + original(old, *_fixture()[:3]) + _need(_finals(old) == _finals(output), "Direct wb overwrite changed") + rows.append({"case": "existing-finals", "outcome": "return"}) + + # One writer invocation cannot populate a reusable data/PASS cache. + state_fixture = _fixture() + snapshot = copy.deepcopy(state_fixture[:3]) + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require) + first = root / "state-first" + first.mkdir() + writer(first, *state_fixture[:3]) + _need(state_fixture[:3] == snapshot, "Serializer mutated input objects") + state_fixture[1]["support"].append(99) + second = root / "state-changed" + second.mkdir() + outcome = _outcome(lambda: writer(second, *state_fixture[:3])) + _need(outcome[0:2] == ("error", "RuntimeError") and not _finals(second), + "Changed input reused a stale serializer PASS") + rows.append({"case": "state-mutation-between-writes", "outcome": outcome}) + + # Unsupported Path subclass delegates before any candidate path operation. + path_events = [] + class ObservedPath(type(root)): + def __truediv__(self, other): + path_events.append(str(other)) + return super().__truediv__(other) + expected = _expected(comparison, _fixture()) + original = _original_writer(comparison, expected) + writer = candidate.make_writer(original, comparison.canonical, expected, comparison.require) + left = root / "path-original" + right = root / "path-candidate" + left.mkdir() + right.mkdir() + original(ObservedPath(left), *_fixture()[:3]) + original_events = list(path_events) + path_events.clear() + writer(ObservedPath(right), *_fixture()[:3]) + _need(path_events == original_events and _finals(left) == _finals(right) and + writer.last_operation["status"] == "LITERAL_REFERENCE_FALLBACK", + "Unsupported path callback/fallback changed") + rows.append({"case": "path-subclass-fallback", "outcome": "return"}) + + _need(comparison.write_scientific.__code__ is original_source, "Original writer changed") + _need(len(rows) <= 128, "Finite serializer case cap exceeded") + actual_bytes = sum(path.stat().st_size for path in root.rglob("*") if path.is_file()) + _need(actual_bytes <= total_cap, "Finite serializer retained-byte cap exceeded") + receipt = {"status": "SERIALIZATION_FINITE_PASS", "case_count": len(rows), + "retained_bytes": actual_bytes, "retained_byte_cap": total_cap, + "optimization": sys.flags.optimize, "cases": rows, + "scope": "Finite exact-schema/unsupported/reference/regular-file controls; no full caller or performance claim"} + (root / "controls.json").write_text(json.dumps(receipt, sort_keys=True, indent=2) + "\n") + return receipt diff --git a/research/h25-authentic-serializer-20261031/consumer/validate_outputs.py b/research/h25-authentic-serializer-20261031/consumer/validate_outputs.py new file mode 100644 index 0000000000..ade0aa6b46 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/consumer/validate_outputs.py @@ -0,0 +1,275 @@ +"""Independent bounded complete validator; imports neither loader nor consumer. + +Input witnesses are streamed directly from newly authenticated fixed transports +against both complete outputs. Only the fixed <=5662-byte certificate and the +fixed <=2674272-byte rank trace are parsed; witness parsing is never repeated. +""" +from __future__ import annotations +import argparse +import gzip +import hashlib +import json +import os +from pathlib import Path +import stat +import sys + +CHUNK = 1048576 +EXPECTED = {'result_sha256': '342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c', +'exact_witness_sha256': '4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82', +'rank_trace_sha256': '85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f', +'rank_call_count': 59959, 'rank_distinct_matrix_count': 252} +SIZES = {'result': 527, 'witness': 58143622, 'rank_trace': 2674272} +PREFIX = 'baseline/evidence/canonical/' +SPECS = { +'witness.json.gz': (16995263, '8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0', 58143622, EXPECTED['exact_witness_sha256']), +'rank-trace.json.gz': (22029, '20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa', 2674272, EXPECTED['rank_trace_sha256']), +'complex-network.json': (5662, '1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f', 5662, '1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f')} +NAMES = ('result.json', 'witness.json', 'rank-trace.json') + + +def need(value, message): + if not value: + raise RuntimeError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + + +def pairs(rows): + result = {} + for key, value in rows: + need(key not in result, 'Duplicate JSON key') + result[key] = value + return result + + +def constant(value): + raise ValueError('Nonfinite JSON constant: ' + value) + + +def parse(raw): + return json.loads(raw.decode('utf-8'), object_pairs_hook=pairs, parse_constant=constant) + + +def identity(info): + return {'dev': info.st_dev, 'ino': info.st_ino, 'mode': stat.S_IMODE(info.st_mode), + 'uid': info.st_uid, 'gid': info.st_gid, 'nlink': info.st_nlink, + 'mtime_ns': info.st_mtime_ns, 'ctime_ns': info.st_ctime_ns} + + +def opened(path): + before = path.lstat() + need(stat.S_ISREG(before.st_mode) and before.st_nlink == 1, 'Expected private regular file: ' + str(path)) + stream = os.fdopen(os.open(path, os.O_RDONLY | os.O_NOFOLLOW), 'rb') + try: + need(identity(os.fstat(stream.fileno())) == identity(before) and os.fstat(stream.fileno()).st_size == before.st_size, + 'File descriptor identity differs') + except BaseException: + stream.close() + raise + return stream, before + + +def unchanged(path, before): + after = path.lstat() + need(identity(after) == identity(before) and after.st_size == before.st_size, 'File changed: ' + str(path)) + + +def custody_check(root, custody): + need(custody['schema'] == 'h25-input-custody-v1' and custody['root'] == str(root), 'Input custody binding differs') + need(root.is_absolute() and root.resolve() == root, 'Input root must be canonical absolute path') + for relative, binding in [('', custody['root_identity'])] + list(custody['directories'].items()): + path = root / relative + info = path.lstat() + need(stat.S_ISDIR(info.st_mode) and stat.S_IMODE(info.st_mode) == 0o555, + 'Input directory mode/type differs') + need(set(identity(info)) == set(binding) and all(type(binding[key]) is int for key in identity(info)) and + identity(info) == binding, 'Input directory identity differs') + need(set(custody['directories']) == {'baseline', 'baseline/evidence', 'baseline/evidence/canonical'}, + 'Input custody directory closure differs') + need(set(custody['files']) == {PREFIX + name for name in SPECS}, 'Input file closure differs') + unique = set() + for name, spec in SPECS.items(): + path = root / PREFIX / name + stream, before = opened(path) + binding = custody['files'][PREFIX + name] + key = (before.st_dev, before.st_ino) + need(key not in unique, 'Aliased input files') + unique.add(key) + need(all(type(binding.get(key)) is int for key in identity(before)) and type(binding.get('size')) is int and + identity(before) == {key: binding[key] for key in identity(before)} and + stat.S_IMODE(before.st_mode) == 0o444 and before.st_size == spec[0] == binding['size'] and + binding['sha256'] == spec[1], 'Input metadata custody differs') + h, count = hashlib.sha256(), 0 + with stream: + while True: + raw = stream.read(CHUNK) + if not raw: + break + count += len(raw) + need(count <= spec[0], 'Transport size overrun') + h.update(raw) + unchanged(path, before) + need(count == spec[0] and h.hexdigest() == spec[1], 'Input transport authentication failed') + + +def bounded_file(path, limit): + stream, before = opened(path) + with stream: + raw = stream.read(limit + 1) + need(len(raw) <= limit and stream.read(1) == b'', 'Bounded metadata overrun') + unchanged(path, before) + return raw + + +def logical(root, name, outputs=(), collect=False): + """Authenticate exact logical bytes and compare fresh regular outputs.""" + spec = SPECS[name] + source = root / PREFIX / name + incoming, before = opened(source) + outgoing = [] + h, total = hashlib.sha256(), 0 + collected = bytearray() if collect else None + try: + for path in outputs: + outgoing.append(opened(path)) + with incoming: + data = gzip.GzipFile(fileobj=incoming, mode='rb') if name.endswith('.gz') else incoming + try: + while True: + raw = data.read(min(CHUNK, spec[2] - total + 1)) + if not raw: + break + total += len(raw) + need(total <= spec[2], 'Logical size overrun') + h.update(raw) + for stream, _ in outgoing: + need(stream.read(len(raw)) == raw, 'Complete output differs from authenticated logical input') + if collect: + collected.extend(raw) + need(total == spec[2] and h.hexdigest() == spec[3], 'Logical digest/final size differs') + for stream, _ in outgoing: + need(stream.read(1) == b'', 'Output trailing data') + finally: + if data is not incoming: + data.close() + finally: + incoming.close() + for path, (stream, facts) in zip(outputs, outgoing): + stream.close() + unchanged(path, facts) + unchanged(source, before) + return {'bytes': total, 'sha256': h.hexdigest()}, collected + + +def validate_receipt(receipt, arm, root, files): + need(receipt['schema'] == 'h25-o03-full-consumer-v1' and + receipt['status'] == 'COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED' and + receipt['arm'] == arm and type(receipt['optimization']) is int and receipt['optimization'] == 0, + 'Full consumer receipt status differs') + for key, schema in [('input_receipt', 'h25-fresh-input-receipt-v1'), + ('after_input_receipt', 'h25-input-authentication-v1')]: + record = receipt[key] + need(record['schema'] == schema and record['custody_before_after'] == 'MATCH' and + record['cached_pass'] is False, 'Fresh input receipt differs') + need(set(record['files']) == {PREFIX + name for name in SPECS}, 'Input receipt closure differs') + for name, spec in SPECS.items(): + row = record['files'][PREFIX + name] + need(row == dict(encoding='gzip' if name.endswith('.gz') else 'plain', + transport_bytes=spec[0], transport_sha256=spec[1], logical_bytes=spec[2], logical_sha256=spec[3]), + 'Input receipt fixed pins differ') + need(receipt['input_receipt']['rank_call_count'] == 59959 and + type(receipt['input_receipt']['rank_call_count']) is int and + receipt['input_receipt']['rank_distinct_matrix_count'] == 252 and + type(receipt['input_receipt']['rank_distinct_matrix_count']) is int, 'Input rank counts differ') + need(receipt['after_input_receipt']['logical_validation'] == 'NOT_PERFORMED_IN_TRANSPORT_READBACK', + 'After input receipt silently supplied logical PASS') + scientific = receipt['scientific_receipt'] + need(scientific == dict(EXPECTED, serialized_bytes=SIZES), 'Independent original EXPECTED mismatch') + need(all(type(scientific[key]) is int for key in ('rank_call_count', 'rank_distinct_matrix_count')), + 'Rank receipt scalar type differs') + need(all(type(value) is int for value in scientific['serialized_bytes'].values()), 'Receipt byte scalar type differs') + need(receipt['files'] == files, 'Consumer file receipt differs') + if arm == 'baseline': + need(receipt['candidate_operation'] is None and receipt['faults_enabled'] is None, 'Baseline used candidate') + return + op = receipt['candidate_operation'] + need(receipt['faults_enabled'] is False and op['status'] == 'BOUNDED_SERIALIZATION_PASS' and + op['phase'] == 'complete', 'Candidate fallback/fault/incomplete route') + for key, value in [('batch_bytes_limit', CHUNK), ('batch_rows_limit', 1024), ('copy_bytes_limit', CHUNK)]: + need(type(op[key]) is int and op[key] == value, 'Bounded limit differs') + need(type(op['batch_count']) is int and 1 <= op['batch_count'] <= 1000000 and + type(op['largest_batch_bytes']) is int and 2 <= op['largest_batch_bytes'] <= CHUNK, + 'Actual bounded batch evidence differs') + need(op['cleanup'] == list(NAMES) + ['stage_directory'], 'Cleanup receipt differs') + stage = Path(op['stage']) + need(stage.parent == root and stage.name.startswith('.serialization-') and not stage.exists() and + not stage.is_symlink(), 'Private stage persists or has wrong identity') + need(set(op['files']) == set(NAMES), 'Bounded file bill incomplete') + for name in NAMES: + row, expected = op['files'][name], files[name] + for key in ('hashed_bytes', 'accepted_write_bytes', 'copy_read_bytes', 'copy_write_bytes'): + need(type(row[key]) is int and row[key] == expected['bytes'], 'Bounded byte counter differs') + need(row['sha256'] == row['copy_sha256'] == expected['sha256'], 'Bounded digest counter differs') + + +def validate(args): + need(sys.flags.optimize == 0, 'Independent validation requires optimization0') + custody = parse(bounded_file(args.custody_json, 65536)) + custody_check(args.input_root, custody) + need(args.baseline_root != args.candidate_root and + (args.baseline_root.stat().st_dev, args.baseline_root.stat().st_ino) != + (args.candidate_root.stat().st_dev, args.candidate_root.stat().st_ino), 'Arms share output root') + for root in (args.baseline_root, args.candidate_root): + need(root.is_absolute() and root.resolve() == root and stat.S_ISDIR(root.lstat().st_mode), 'Invalid output root') + need(set(p.name for p in root.iterdir()) == set(NAMES), 'Unexpected output/failure/staging file') + cert_facts, cert_raw = logical(args.input_root, 'complex-network.json', collect=True) + certificate = parse(cert_raw) + result = {key: certificate[key] for key in ('circuit', 'side_map', 'labels', 'role_frames')} + result_raw = canonical(result) + need(len(result_raw) == SIZES['result'] and hashlib.sha256(result_raw).hexdigest() == EXPECTED['result_sha256'], + 'Independent original literal result projection differs') + files = {'result.json': {'bytes': len(result_raw), 'sha256': hashlib.sha256(result_raw).hexdigest()}} + for root in (args.baseline_root, args.candidate_root): + need(bounded_file(root / 'result.json', 527) == result_raw, 'Complete result output differs') + for source, output in [('witness.json.gz', 'witness.json'), ('rank-trace.json.gz', 'rank-trace.json')]: + facts, raw = logical(args.input_root, source, + [args.baseline_root / output, args.candidate_root / output], collect=(output == 'rank-trace.json')) + files[output] = facts + if raw is not None: + ranks = parse(raw) + need(type(ranks) is list and len(ranks) == 59959, 'Independent full rank count differs') + distinct = set() + for event in ranks: + need(type(event) is list and len(event) == 2 and type(event[0]) is list and + type(event[1]) is int and all(type(row) is int for row in event[0]), 'Rank exact-int schema differs') + distinct.add(tuple(event[0])) + need(len(distinct) == 252, 'Independent distinct rank count differs') + del ranks, distinct, raw + for arm, root, path in [('baseline', args.baseline_root, args.baseline_receipt), + ('candidate', args.candidate_root, args.candidate_receipt)]: + validate_receipt(parse(bounded_file(path, 65536)), arm, root, files) + custody_check(args.input_root, custody) + report = {'schema': 'h25-o03-independent-complete-validation-v1', 'status': 'COMPLETE_OUTPUTS_VALIDATED', + 'expected': EXPECTED, 'files': files, 'certificate': cert_facts, + 'comparison_chunk_bytes': CHUNK, 'rank_parse_cap_bytes': 2674272, + 'independence': 'No loader/consumer/candidate imports; fixed independent pins, literal original canonical and certificate projection; complete source logical bytes compared with both outputs', + 'scope': 'Exact complete retained values only; resource/custody/runtime envelope and O03 adjudication remain separate'} + encoded = json.dumps(report, sort_keys=True, indent=2).encode('ascii') + b'\n' + with args.report.open('xb') as stream: + need(stream.write(encoded) == len(encoded), 'Short validation report write') + return report + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + for name in ('input-root', 'custody-json', 'baseline-root', 'candidate-root', 'baseline-receipt', 'candidate-receipt', 'report'): + parser.add_argument('--' + name, type=Path, required=True) + args = parser.parse_args() + print(json.dumps({'status': validate(args)['status']}, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/complex-network.json b/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/complex-network.json new file mode 100644 index 0000000000..62a6091887 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/complex-network.json @@ -0,0 +1,143 @@ +{ + "bit_saving": "37/12500000000", + "circuit": { + "additions": 80595, + "disjoint_additions": 68595, + "h": 25, + "injections": 27600, + "pair_star_additions": 12000, + "roles": 108195, + "roles_per_target": 47.041, + "v": 2300 + }, + "complex_counts": { + "I": 15870000, + "L": 10315500000, + "N": 12167000000, + "W": 1741801270000, + "central_roles": 26, + "deficit": 3703000000, + "eta": "28/205789375", + "h": 25, + "m": 15625, + "original_side_wires_per_invocation": 3693800, + "s": 27215641140750000, + "side_roles_per_invocation": 108195, + "v": 2300 + }, + "complex_deficit_slack": "6761797/8231575000000000", + "complex_saving": "7/500000000", + "gates": { + "gates_per_invocation": 340784, + "total_gates": 5408242080000, + "twelve_W": 20901615240000 + }, + "improvement_over_compact_control": "590/83", + "labels": { + "active_nodes": 82895, + "all_labels_nondegenerate": true, + "all_residuals_have_odd_vectors": true, + "checked_inclusions": 188790 + }, + "log_enclosure": [ + "1003674733095412338935264801206694829502804118660273821722358572561777951813562324984581151664909098376456139346987946438356114944865114544057566309229396051200891281693308045036569381219925884240815457348697380244265196736/103936362434495646010619550865033734742948881177937982419226476521510946436948314218071351858470876811875561920539687733866419026027866373569756270393100104240876895441796280524990301784985328254889750901950661699188332905", + "119905674780465260758132999318298249674205865631153226854493684575647168973933813765866273005815485563618924127097549911779010579460799218169313950759672923946122257420539013677630274686709038285230521425787947340179037163618384721/12416930765507746510068682343342696843957626338057657633016923061769841067667425271918924168691987416458733797440474694605908192976129102762466882436295692453310093108779928980052174719912913882184162241086372384329699504384000000" + ], + "log_m_upper": "483/50", + "role_frames": { + "forward_frames_nested": true, + "reverse_complement_frames_nested": true, + "roles": 108195 + }, + "scope": "Conditional on the pinned upstream interfaces, the compact-control movement and guard proofs, the paired bit network, and the written binary-frame transfer for this complex side circuit. Exact arithmetic and finite checks are not formal verification.", + "scoped_ceiling": { + "below_2_to_minus_30": true, + "scope": "Published h=50 paired bit network and retained Gaussian margin; not a bound on other networks or algorithms.", + "upper": "37/62500000000" + }, + "side_map": { + "coefficients": "+1/2 disjoint, -1/2 intersection two", + "nonzero_coefficients": 3693800, + "side_map_exact": true, + "targets": 2300 + }, + "status": "CONDITIONAL 59/10^11 WITNESS; COMPRESSED COMPLEX SIDE CIRCUIT; NOT FORMAL VERIFICATION", + "upstream_commit": "adc7f1241b42e322a6451854ab7e4b4c146bf78a", + "witness": { + "absorption_gap": "29261/25000000000000000", + "constraint_slacks": { + "K_dominates_log_p": "19979001/100000000", + "K_smaller_than_ell": "60021999/100000000", + "alpha_below_sqrt_p": "80001/400000", + "beta_below_one": "999/1000", + "beta_positive": "1/1000", + "c_positive": "999/1000", + "crt_layout": "2960037/1250000000000000", + "delta_below_one_eighth": "124999/1000000", + "delta_positive": "1/1000000", + "dimension_upper_bound": "40003/300000", + "epsilon_positive": "19999/100000", + "gamma_sublinear": "40003/200000", + "gaussian_cost": "23/2000000", + "guard_width": "829961/1000000000", + "kappa_positive": "59/100000000000", + "lambda_above_sigma": "5521/500000000000", + "lambda_above_tau": "1/500000000000", + "lambda_below_one": "1479/500000000000", + "lambda_prime_above_lambda": "1/500000000000", + "lambda_prime_below_one": "739/250000000000", + "leaf_cost": "1103/100000000000", + "packed_overhead": "1/500000000000", + "prefix_cost": "60021999/100000000", + "prime_interval_growth": "30001/50000", + "r_superpolynomial": "80001/100000", + "reserved_axes": "249749999261/250000000000", + "scalar_cost": "800009/1000000", + "sigma_below_one": "7/500000000", + "sigma_positive": "499999993/500000000", + "tau_below_one": "37/12500000000", + "tau_positive": "12499999963/12500000000" + }, + "guard": { + "B": 338201706233372774319109678801287590064, + "C0": 321727027889740762489223803495350305328695729120143793284991524019954162292886152000000, + "C1": "49961/10000", + "E": 338201706233372774319082463160146840064, + "beta": "1/1000", + "m": 15625, + "s": 27215641140750000, + "zeta": "1/10000" + }, + "limiting_margins": [ + "g3" + ], + "margins": { + "g1": "60021999/100000000", + "g2": "739223037/1250000000000000000", + "g3": "14779261/25000000000000000", + "g4": "2960037/1250000000000000", + "g5": "23/2000000", + "g6": "800009/1000000", + "g7": "19999/100000" + }, + "minimum_margin": "14779261/25000000000000000", + "parameters": { + "C1": "49961/10000", + "beta": "1/1000", + "c": "999/1000", + "delta": "1/1000000", + "epsilon": "19999/100000", + "kappa": "59/100000000000", + "lam": "499999998521/500000000000", + "lamp": "249999999261/250000000000", + "sigma": "499999993/500000000", + "tau": "12499999963/12500000000" + }, + "recurrence": { + "internal": "12499999963/12500000000", + "layer": "12499999963/12500000000", + "leaf": "499999993007/500000000000", + "preprocessing": "1/1000" + } + } +} diff --git a/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/rank-trace.json.gz b/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/rank-trace.json.gz new file mode 100644 index 0000000000..8b071cc725 Binary files /dev/null and b/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/rank-trace.json.gz differ diff --git a/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/witness.json.gz b/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/witness.json.gz new file mode 100644 index 0000000000..4d7d6a59c7 Binary files /dev/null and b/research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/witness.json.gz differ diff --git a/research/h25-authentic-serializer-20261031/loader/API-v1.md b/research/h25-authentic-serializer-20261031/loader/API-v1.md new file mode 100644 index 0000000000..ec051bd35a --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/API-v1.md @@ -0,0 +1,78 @@ +# Authentic frozen H25 input API + +`frozen_h25_inputs.load_frozen_inputs(input_root: pathlib.Path, custody: dict)` +returns a dictionary with exactly `result`, `witness`, `ranks`, `input_receipt`. +The public function always uses the three literal complete-H25 input pins and +59,959 ordered events / 252 distinct rows. It has no fixture-mode argument. +Every invocation reads and authenticates all inputs afresh. Values are exact +built-ins; list order is retained; source tuple positions are restored. Historical +alias/allocation topology and dict insertion order erased by canonical sorting +are not reconstructed. Each arm must run in a fresh process/root with its own +loaded values. No saved PASS exists. + +`authenticate_inputs(input_root, custody)` performs fresh complete transport +hashing between custody checks. It returns an additive transport-only receipt; +it does not perform decoding/schema validation or authorize a subsequent load. +The consumer calls this after writing. The independent output validator uses its +own pinned transport/logical stream comparison and result projection. + +`InputError(RuntimeError)` reports loader custody/authentication/schema errors. +Underlying gzip and JSON/decimal errors propagate; no failure is converted into +a receipt. No `assert` enforces a condition, so normal and optimized controls +have the same required outcomes. `strict_json` rejects duplicate object keys, +NaN/Infinity constants and numeric floating overflow in every parsed position. +It leaves Python's integer conversion limit untouched, keeps arbitrary-width +integers permitted by that original conversion contract and preserves its +decimal-conversion ValueError. Result exact-int fields reject bool; source bool +fields preserve both True/False; circuit.roles_per_target must remain finite +exact float. No values are cast from bool/float to integer. + +Input root is an absolute canonically spelled local Path. The root and three +traversed directories are real directories mode0555. Relative input paths are +`baseline/evidence/canonical/witness.json.gz`, +`baseline/evidence/canonical/rank-trace.json.gz`, and +`baseline/evidence/canonical/complex-network.json`. Each file is regular0444, +has nlink1 and a distinct (device,inode). Every file open uses O_NOFOLLOW and +O_CLOEXEC; fstat checks bind the held fd to the sealed identity. Symlinks, +aliases, unexpected fields and before/after identity/byte changes fail closed. +Input copies and sealing are parent/envelope duties, not work done by loader. + +Custody exact keys: + +```json +{"schema":"h25-input-custody-v1","root":"ABSOLUTE_PATH", + "root_identity":{"dev":0,"ino":0,"mode":365,"uid":0,"gid":0,"nlink":0,"mtime_ns":0,"ctime_ns":0}, + "directories":{"baseline":"IDENTITY_OBJECT","baseline/evidence":"IDENTITY_OBJECT","baseline/evidence/canonical":"IDENTITY_OBJECT"}, + "files":{"RELATIVE_PATH":{"dev":0,"ino":0,"mode":292,"uid":0,"gid":0,"nlink":1,"mtime_ns":0,"ctime_ns":0,"size":0,"sha256":"FIXED_PIN"}}} +``` + +Illustrative numeric zeroes above must be replaced by actual independently sealed +metadata; identity objects have exactly their listed fields. Root/ancestor +ownership and source/runtime closure are admitted separately by the envelope. +The loader establishes fresh before/after immutable bindings, not immunity from +a privileged adversary or historical old-stage custody. + +The logical reader authenticates the full transport before opening gzip/plain +logical reads. Each read requests at most1MiB and only remaining-size+1. A size +overrun fails before extending the logical buffer. Logical final size/digest +are checked before JSON parsing. Parsing/restoration is eager: logical bytes, +JSON decoder Unicode and decoded/restored containers can coexist. This is a +bounded-by-pinned-input loader; it is not a streaming object parser or a claim +that the full eager replay fits1GiB/180s. Gzip internal buffering/runtime closure +and actual resource peaks must be reviewed/measured. + +The loading bill is two complete transport hash passes (34,045,908 bytes), one +gzip transport reread (17,017,292 bytes), one plain certificate reread (5,662 +bytes), logical hash/parse work (60,823,556 bytes), all metadata/fd checks, +restoration/allocation and rank-distinct work. Each subsequent authenticate call +adds one transport hash pass (17,022,954 bytes) and its custody checks. Python +buffer reallocations and temporary conversions are additional paid work. + +Run the concrete ordered control source only after independent complete source +and operation admission. A future parent command can invoke Python -B -I on +`frozen_input_controls.py`, normal then -O; the script explicitly adds its sealed +sibling loader directory. Each mode requires the 39 exact names/order in +CONTROL-SPEC-v1.json. Those controls cover prospective families1-19. Consumer +controls supply family20 (literal fallback receives no bounded-path credit), +the complete writer checks and the unchanged original70 cases per mode. +Source readiness is not execution admission or runtime qualification. diff --git a/research/h25-authentic-serializer-20261031/loader/CONTROL-SPEC-v1.json b/research/h25-authentic-serializer-20261031/loader/CONTROL-SPEC-v1.json new file mode 100644 index 0000000000..dc7ba9e274 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/CONTROL-SPEC-v1.json @@ -0,0 +1,75 @@ +{ + "failure_semantics": "first failure propagates, no PASS receipt; parent retains stderr/guard/evidence", + "family_20_owner": "consumer: literal fallback no bounded credit", + "fixture_scope": "finite controls only, private _load with separate fixture pins; public genuine API has no fixture mode", + "ordered_count": 39, + "ordered_names": [ + "L01_valid_schema_types_order_fresh_ownership", + "L02_transport_hash_before_decode", + "L03_transport_size_before_decode", + "L04_invalid_gzip", + "L05_truncated_gzip", + "L06_logical_size_overrun", + "L07_logical_final_size_before_parse", + "L08_logical_digest_before_parse", + "L09_duplicate_json_keys", + "L10_nonfinite_json_nan", + "L11_nonfinite_json_infinity", + "L12_wrong_witness_key_set", + "L13_wrong_code_key_set", + "L14_unsupported_kind_leaf", + "L15_args_arity", + "L16_args_bool_int_rejected", + "L17_label_bad_tag", + "L18_label_tag_arity", + "L19_basis_order_retained", + "L20_gate_order_retained", + "L21_source_order_retained", + "L22_output_order_retained", + "L23_arbitrary_width_ints", + "L24_unchanged_decimal_error", + "L25_duplicate_rank_events_retained", + "L26_rank_row_bool_rejected", + "L27_rank_result_bool_rejected", + "L28_result_int_bool_rejected", + "L29_result_float_not_int", + "L30_result_nonfinite_float_rejected", + "L31_wrong_rank_count", + "L32_wrong_distinct_count", + "L33_mode_drift_no_cached_pass", + "L34_byte_drift_no_cached_pass", + "L35_symlink_rejected", + "L36_hardlink_rejected", + "L37_before_after_mode_drift", + "L38_before_after_byte_drift", + "L39_numeric_float_overflow" + ], + "prospective_families_covered": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19 + ], + "required_modes": [ + 0, + 1 + ], + "schema": "h25-loader-control-spec-v1", + "source": "frozen_input_controls.py", + "status": "AUTHORED_UNEXECUTED" +} diff --git a/research/h25-authentic-serializer-20261031/loader/PACKAGE-PINS-v1.json b/research/h25-authentic-serializer-20261031/loader/PACKAGE-PINS-v1.json new file mode 100644 index 0000000000..0349985c43 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/PACKAGE-PINS-v1.json @@ -0,0 +1,36 @@ +{ + "control_count_per_mode": 39, + "files": { + "API-v1.md": { + "bytes": 5012, + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + "CONTROL-SPEC-v1.json": { + "bytes": 2002, + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + "PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + "SOURCE-PINS-v1.json": { + "bytes": 2395, + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + "SOURCE-READINESS-v1.json": { + "bytes": 2306, + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + "frozen_h25_inputs.py": { + "bytes": 14650, + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "frozen_input_controls.py": { + "bytes": 13181, + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + } + }, + "schema": "h25-loader-package-pins-v1", + "self_hash_excluded": true, + "status": "FROZEN_SOURCE_UNEXECUTED" +} diff --git a/research/h25-authentic-serializer-20261031/loader/PASSIVE-ATTEMPTS-v1.json b/research/h25-authentic-serializer-20261031/loader/PASSIVE-ATTEMPTS-v1.json new file mode 100644 index 0000000000..75850f7bb3 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/PASSIVE-ATTEMPTS-v1.json @@ -0,0 +1,23 @@ +{ + "attempts": [ + { + "error": "not a git repository; GIT_DISCOVERY_ACROSS_FILESYSTEM not set", + "exit": 128, + "operation": "git status scoped loader directory", + "status": "FAILED_RETAINED", + "target_work": false + } + ], + "controls_tests_benchmarks": 0, + "decodes_decompressions": 0, + "protected_runs_access": 0, + "schema": "h25-loader-passive-attempts-v1", + "source_AST_files": [ + "frozen_h25_inputs.py", + "frozen_input_controls.py" + ], + "source_AST_parsed": true, + "source_pin_mismatches": 0, + "target_calls": 0, + "target_imports": 0 +} diff --git a/research/h25-authentic-serializer-20261031/loader/SOURCE-PINS-v1.json b/research/h25-authentic-serializer-20261031/loader/SOURCE-PINS-v1.json new file mode 100644 index 0000000000..b584cb6cde --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/SOURCE-PINS-v1.json @@ -0,0 +1,48 @@ +{ + "files": { + "AGENTS.md": { + "bytes": 387, + "expected_sha256": "55a69a8d4bd1779075f3b5a19c6ea8d5011ab060b1fb9bb7ba4ea59ab7bfc2b6", + "matches": true, + "sha256": "55a69a8d4bd1779075f3b5a19c6ea8d5011ab060b1fb9bb7ba4ea59ab7bfc2b6" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json": { + "bytes": 1926, + "expected_sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "matches": true, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py": { + "bytes": 19732, + "expected_sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "matches": true, + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py": { + "bytes": 6105, + "expected_sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", + "matches": true, + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json": { + "bytes": 1912, + "expected_sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "matches": true, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/integration/full_driver.py": { + "bytes": 22480, + "expected_sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "matches": true, + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + } + }, + "method": "passive source text/AST/metadata only; no target import/call/decode", + "schema": "h25-loader-source-pins-v1", + "source_schema_anchors": { + "complex_circuit.py": "32-57,173-178,221-223,271-294,330-373,409-410", + "complex_network.py": "90-105", + "full_driver.py": "322-328 exact projection" + }, + "unchanged_originals": true +} diff --git a/research/h25-authentic-serializer-20261031/loader/SOURCE-READINESS-v1.json b/research/h25-authentic-serializer-20261031/loader/SOURCE-READINESS-v1.json new file mode 100644 index 0000000000..13057e9023 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/SOURCE-READINESS-v1.json @@ -0,0 +1,87 @@ +{ + "concrete_loader_controls": { + "count_per_mode": 39, + "modes": [ + 0, + 1 + ], + "ordered_spec": "CONTROL-SPEC-v1.json", + "prospective_families": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19 + ] + }, + "consumer_family20_dependency": "consumer controls", + "controls_executed": 0, + "created_utc": "2026-10-31T08:09:56.394016+00:00", + "deficiencies": [ + "Full actual runtime dependency seal and operation admission belong to envelope/parent.", + "Source-only checks do not prove authentic payload schema admission, bounded candidate fast path, memory/cost fit or O03 qualification." + ], + "execution_admitted": false, + "external_dependencies": { + "dynamic_closure_status": "ENVELOPE_OWNED_PENDING_NOT_PROVEN_BY_DIRECT_IMPORT_LIST", + "nonstdlib": [], + "providers": [ + "gzip", + "built-in zlib in fixed interpreter plus linked libz", + "json plus _json", + "hashlib selected _hashlib/_sha2 provider and linked libcrypto if selected", + "math extension", + "os/stat/pathlib/io and actual transitive bootstrap imports", + "controls gzip/tempfile/shutil/sys plus actual transitive branches" + ], + "runtime": "CPython3.12 interpreter/source/shared-library complete effective closure must be envelope-admitted before execution" + }, + "genuine_payloads_decoded": 0, + "imports_direct": { + "frozen_h25_inputs.py": [ + "gzip", + "hashlib", + "json", + "math", + "os", + "pathlib", + "stat" + ], + "frozen_input_controls.py": [ + "frozen_h25_inputs", + "gzip", + "hashlib", + "json", + "os", + "pathlib", + "shutil", + "sys", + "tempfile" + ] + }, + "lane": "I1", + "original_EXPECTED_changed": false, + "public_API": { + "authenticate_inputs": "(Path,custody dict)->transport-only fresh authentication receipt", + "load_frozen_inputs": "(Path,custody dict)->dict[result,witness,ranks,input_receipt]" + }, + "resource_fit": "UNMEASURED_UNKNOWN", + "runtime_qualified": false, + "schema": "h25-loader-source-readiness-v1", + "source_readonly_material_changed": false, + "status": "READY_FOR_INDEPENDENT_SOURCE_REVIEW_ONLY" +} diff --git a/research/h25-authentic-serializer-20261031/loader/frozen_h25_inputs.py b/research/h25-authentic-serializer-20261031/loader/frozen_h25_inputs.py new file mode 100644 index 0000000000..f81eff3319 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/frozen_h25_inputs.py @@ -0,0 +1,322 @@ +"""Authentic retained-value H25 loader. Importing this module performs no I/O. + +No scientific code is imported. Public loading always uses the fixed pins below; +private helpers are exposed only to the separately reviewed finite controls. +Custody establishes a fresh immutable replay, not historical allocation aliases. +""" +import gzip +import hashlib +import json +import math +import os +from pathlib import Path +import stat + +CHUNK_BYTES = 1048576 +INPUT_SPECS = { + "baseline/evidence/canonical/witness.json.gz": { + "encoding": "gzip", "transport_bytes": 16995263, + "transport_sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "logical_bytes": 58143622, + "logical_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82"}, + "baseline/evidence/canonical/rank-trace.json.gz": { + "encoding": "gzip", "transport_bytes": 22029, + "transport_sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "logical_bytes": 2674272, + "logical_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f"}, + "baseline/evidence/canonical/complex-network.json": { + "encoding": "plain", "transport_bytes": 5662, + "transport_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "logical_bytes": 5662, + "logical_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f"}, +} +DIRECTORIES = ("baseline", "baseline/evidence", "baseline/evidence/canonical") +IDENTITY_FIELDS = ("dev", "ino", "mode", "uid", "gid", "nlink", "mtime_ns", "ctime_ns") +LOCAL_PATH_TYPE = type(Path()) +RESULT_KEYS = ("circuit", "side_map", "labels", "role_frames") +WITNESS_KEYS = ("support", "args", "kind", "active", "pieces", "labels", "code") + + +class InputError(RuntimeError): + """Schema, authentication or custody failure; never a saved PASS.""" + + +def need(condition, message): + if not condition: + raise InputError(message) + + +def identity(info, file=False): + out = {name: getattr(info, "st_" + name) for name in IDENTITY_FIELDS if name != "mode"} + out["mode"] = stat.S_IMODE(info.st_mode) + if file: + out["size"] = info.st_size + return out + + +def _exact_keys(value, names, where): + need(type(value) is dict and set(value) == set(names), where + ": exact keys") + return value + + +def _check_identity(info, expected, is_file, where): + need(type(expected) is dict, where + ": identity object") + _exact_keys(expected, IDENTITY_FIELDS + (("size", "sha256") if is_file else ()), where + " identity") + actual = identity(info, is_file) + for key, value in actual.items(): + need(type(expected.get(key)) is int and expected[key] == value, where + ": identity " + key) + need(stat.S_ISREG(info.st_mode) if is_file else stat.S_ISDIR(info.st_mode), where + ": regular kind") + need(actual["mode"] == (0o444 if is_file else 0o555), where + ": immutable mode") + if is_file: + need(actual["nlink"] == 1, where + ": unique link") + + +def check_custody(root, custody, specs=None): + """Check fresh metadata every call. Hashing happens separately on held fds.""" + if specs is None: + specs = INPUT_SPECS + need(type(root) is LOCAL_PATH_TYPE, "root: exact local Path") + need(root.is_absolute() and str(root.resolve(strict=True)) == str(root), "root: canonical absolute path") + _exact_keys(custody, ("schema", "root", "root_identity", "directories", "files"), "custody") + need(custody["schema"] == "h25-input-custody-v1" and custody["root"] == str(root), "custody: root binding") + _check_identity(root.lstat(), custody["root_identity"], False, "root") + _exact_keys(custody["directories"], DIRECTORIES, "custody directories") + for relative in DIRECTORIES: + _check_identity((root / relative).lstat(), custody["directories"][relative], False, relative) + _exact_keys(custody["files"], specs, "custody files") + unique = set() + for relative, spec in specs.items(): + expected = custody["files"][relative] + _check_identity((root / relative).lstat(), expected, True, relative) + need(expected.get("size") == spec["transport_bytes"], relative + ": transport size") + need(expected.get("sha256") == spec["transport_sha256"], relative + ": fixed transport pin") + key = (expected["dev"], expected["ino"]) + need(key not in unique, relative + ": input alias") + unique.add(key) + + +def _open_checked(root, relative, expected): + fd = os.open(root / relative, os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC) + try: + _check_identity(os.fstat(fd), expected, True, relative) + return os.fdopen(fd, "rb") + except BaseException: + os.close(fd) + raise + + +def _transport_hash(root, relative, spec, expected): + digest = hashlib.sha256() + count = 0 + with _open_checked(root, relative, expected) as source: + while True: + block = source.read(CHUNK_BYTES) + if not block: + break + count += len(block) + need(count <= spec["transport_bytes"], relative + ": transport size overrun") + digest.update(block) + _check_identity(os.fstat(source.fileno()), expected, True, relative) + need(count == spec["transport_bytes"], relative + ": transport size mismatch") + need(digest.hexdigest() == spec["transport_sha256"], relative + ": transport hash mismatch") + + +def _read_logical(root, relative, spec, expected): + """Authenticate transport before decoding; cap logical allocation at size+1. + + gzip reads are bounded, including a one-byte overrun sentinel. The complete + logical digest/final size are authenticated BEFORE any JSON parser is called. + gzip errors retain their original exception, including invalid/truncated data. + """ + _transport_hash(root, relative, spec, expected) + logical = bytearray() + digest = hashlib.sha256() + with _open_checked(root, relative, expected) as source: + reader = gzip.GzipFile(fileobj=source, mode="rb") if spec["encoding"] == "gzip" else source + try: + while True: + block = reader.read(min(CHUNK_BYTES, spec["logical_bytes"] - len(logical) + 1)) + if not block: + break + need(len(logical) + len(block) <= spec["logical_bytes"], relative + ": logical overrun") + logical.extend(block) + digest.update(block) + finally: + if reader is not source: + reader.close() + _check_identity(os.fstat(source.fileno()), expected, True, relative) + need(len(logical) == spec["logical_bytes"], relative + ": logical size mismatch") + need(digest.hexdigest() == spec["logical_sha256"], relative + ": logical hash mismatch") + return logical + + +def _pairs(pairs): + out = {} + for key, value in pairs: + need(key not in out, "JSON: duplicate key " + key) + out[key] = value + return out + + +def _constant(value): + raise InputError("JSON: nonfinite constant " + value) + + +def _float(value): + number = float(value) + need(math.isfinite(number), "JSON: nonfinite floating value") + return number + + +def strict_json(data): + # Default parse_int preserves Python arbitrary-width semantics AND its + # unchanged configured decimal conversion ValueError. No limit adjustment. + return json.loads(data, object_pairs_hook=_pairs, parse_constant=_constant, parse_float=_float) + + +def _int(value, where): + need(type(value) is int, where + ": exact int") + return value + + +def _list(value, where): + need(type(value) is list, where + ": exact list") + return value + + +def _arity(value, count, where): + _list(value, where) + need(len(value) == count, where + ": arity") + return value + + +def _ints(value, where, count=None): + _list(value, where) + if count is not None: + need(len(value) == count, where + ": arity") + return tuple(_int(item, where) for item in value) + + +def restore_result(certificate): + need(type(certificate) is dict and all(key in certificate for key in RESULT_KEYS), "certificate: projection keys") + result = {} + fields = { + "circuit": (("h", "v", "additions", "injections", "roles", "disjoint_additions", "pair_star_additions"), (), (), ("roles_per_target",)), + "side_map": (("targets", "nonzero_coefficients"), ("side_map_exact",), ("coefficients",), ()), + "labels": (("active_nodes", "checked_inclusions"), ("all_labels_nondegenerate", "all_residuals_have_odd_vectors"), (), ()), + "role_frames": (("roles",), ("forward_frames_nested", "reverse_complement_frames_nested"), (), ()), + } + for key in RESULT_KEYS: + integers, bools, strings, floats = fields[key] + value = _exact_keys(certificate[key], integers + bools + strings + floats, "result." + key) + restored = {} + for name in integers: + restored[name] = _int(value[name], "result." + key + "." + name) + for name in bools: + need(type(value[name]) is bool, "result." + key + "." + name + ": bool") + restored[name] = value[name] + for name in strings: + need(type(value[name]) is str, "result." + key + "." + name + ": str") + restored[name] = value[name] + for name in floats: + need(type(value[name]) is float and math.isfinite(value[name]), "result." + key + "." + name + ": finite float") + restored[name] = value[name] + result[key] = restored + return result + + +def restore_witness(value): + _exact_keys(value, WITNESS_KEYS, "witness") + support = list(_ints(value["support"], "support")) + args = [None if item is None else _ints(item, "args", 2) for item in _list(value["args"], "args")] + kinds = [] + for item in _list(value["kind"], "kind"): + need(item is None or type(item) is str, "kind: None or str") + kinds.append(item) + need(len(support) == len(args) == len(kinds), "witness: aligned node lists") + active = list(_ints(value["active"], "active")) + pieces = [] + for item in _list(value["pieces"], "pieces"): + target, node, coefficient = _arity(item, 3, "piece") + pieces.append((_ints(target, "piece target", 3), _int(node, "piece node"), _ints(coefficient, "coefficient", 2))) + labels = [] + for item in _list(value["labels"], "labels"): + key, basis, dim, label_key = _arity(item, 4, "label") + if type(key) is not int: + tag, triple = _arity(key, 2, "label tagged key") + need(type(tag) is str and tag == "perp", "label: literal perp tag") + key = (tag, _ints(triple, "label target", 3)) + labels.append((key, [_ints(pair, "basis pair", 2) for pair in _list(basis, "basis")], _int(dim, "label dim"), _ints(label_key, "label key"))) + code = _exact_keys(value["code"], ("roles", "gates", "sources", "outputs"), "code") + gates = [] + for item in _list(code["gates"], "gates"): + node, inputs, outputs = _arity(item, 3, "gate") + gates.append((_int(node, "gate node"), _ints(inputs, "gate inputs"), _ints(outputs, "gate outputs"))) + sources = [] + for item in _list(code["sources"], "sources"): + triple, slot = _arity(item, 2, "source") + sources.append((_ints(triple, "source triple", 3), _int(slot, "source slot"))) + outputs = [_ints(item, "output", 2) for item in _list(code["outputs"], "outputs")] + return {"support": support, "args": args, "kind": kinds, "active": active, + "pieces": pieces, "labels": labels, + "code": {"roles": _int(code["roles"], "code.roles"), "gates": gates, "sources": sources, "outputs": outputs}} + + +def restore_ranks(value, expected_count=59959, expected_distinct=252): + ranks = [] + for event in _list(value, "ranks"): + rows, rank = _arity(event, 2, "rank event") + ranks.append((_ints(rows, "rank rows"), _int(rank, "rank result"))) + need(len(ranks) == expected_count, "rank: full event count") + need(len({rows for rows, _ in ranks}) == expected_distinct, "rank: distinct row count") + return ranks + + +def _load(root, custody, specs, expected_count, expected_distinct): + check_custody(root, custody, specs) + values = [] + receipt = {} + # Fixed order witness,rank,certificate. Logical buffers die after each parse; + # decoded and restored containers overlap during each restoration, billed. + for relative, spec in specs.items(): + data = _read_logical(root, relative, spec, custody["files"][relative]) + parsed = strict_json(data) + del data + if relative.endswith("witness.json.gz"): + restored = restore_witness(parsed) + elif relative.endswith("rank-trace.json.gz"): + restored = restore_ranks(parsed, expected_count, expected_distinct) + else: + restored = restore_result(parsed) + values.append(restored) + del parsed, restored + receipt[relative] = dict(spec) + # Rehash all original transports; metadata alone never supplies cached PASS. + check_custody(root, custody, specs) + for relative, spec in specs.items(): + _transport_hash(root, relative, spec, custody["files"][relative]) + check_custody(root, custody, specs) + witness, ranks, result = values + return {"result": result, "witness": witness, "ranks": ranks, + "input_receipt": {"schema": "h25-fresh-input-receipt-v1", "scope": "authentic retained values; historical aliases not recovered", "files": receipt, + "rank_call_count": len(ranks), "rank_distinct_matrix_count": len({rows for rows, _ in ranks}), + "custody_before_after": "MATCH", "cached_pass": False}} + + +def load_frozen_inputs(input_root, custody): + """Load complete authentic data; caller cannot replace fixed pins or counts.""" + return _load(input_root, custody, INPUT_SPECS, 59959, 252) + + +def authenticate_inputs(input_root, custody): + """Fresh complete transport-only readback, including both metadata edges. + + This never supplies schema/logical PASS or skips work on a later load. It + supports the consumer's after-writer custody edge without reloading values. + """ + check_custody(input_root, custody) + for relative, spec in INPUT_SPECS.items(): + _transport_hash(input_root, relative, spec, custody["files"][relative]) + check_custody(input_root, custody) + return {"schema": "h25-input-authentication-v1", "files": {p: dict(s) for p, s in INPUT_SPECS.items()}, + "custody_before_after": "MATCH", "cached_pass": False, "logical_validation": "NOT_PERFORMED_IN_TRANSPORT_READBACK"} diff --git a/research/h25-authentic-serializer-20261031/loader/frozen_input_controls.py b/research/h25-authentic-serializer-20261031/loader/frozen_input_controls.py new file mode 100644 index 0000000000..6bae29c38e --- /dev/null +++ b/research/h25-authentic-serializer-20261031/loader/frozen_input_controls.py @@ -0,0 +1,291 @@ +"""Ordered concrete loader controls. SOURCE ONLY until parent admission. + +Finite pins below are constructed only within controls and are never passed to +the public genuine loader. No fixture, decoder or target work occurs at import. +""" +import gzip +import hashlib +import json +import os +from pathlib import Path +import shutil +import sys +import tempfile + +# -I excludes the script directory. The parent seals this exact sibling source +# and full bootstrap/runtime closure before dispatch; no ambient import lookup. +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import frozen_h25_inputs as loader + + +def require(value, message): + if not value: + raise RuntimeError(message) + + +def rejects(function, expected, fragment=None): + try: + function() + except expected as error: + require(fragment is None or fragment in str(error), "wrong rejection: " + str(error)) + return + raise RuntimeError("expected rejection missing") + + +def corpus(): + result = { + "circuit": {"h": 8, "v": 56, "additions": 1, "injections": 2, "roles": 3, + "roles_per_target": 0.125, "disjoint_additions": 1, "pair_star_additions": 0}, + "side_map": {"targets": 56, "nonzero_coefficients": 2, "side_map_exact": True, "coefficients": "+1/2 disjoint, -1/2 intersection two"}, + "labels": {"active_nodes": 2, "checked_inclusions": 1, "all_labels_nondegenerate": True, "all_residuals_have_odd_vectors": False}, + "role_frames": {"roles": 3, "forward_frames_nested": True, "reverse_complement_frames_nested": False}} + witness = {"support": [0, 1 << 300, (1 << 300) + 1], "args": [None, None, [1, 1]], + "kind": [None, "in", "d0"], "active": [2, 1], + "pieces": [[[2, 0, 1], 2, [-1, 2]]], + "labels": [[2, [[9, 17], [1, 3]], 2, [17, 3]], [["perp", [2, 0, 1]], [[4, 19]], 1, [19]]], + "code": {"roles": 3, "gates": [[2, [1, 0], [1, 2]], [1, [0], [0, 1]]], + "sources": [[[2, 0, 1], 2], [[1, 2, 3], 0]], "outputs": [[2, 1], [0, 2]]}} + ranks = [[[3, 1], 2], [[5], 1], [[3, 1], 2]] + return witness, ranks, result + + +class Fixture: + def __init__(self, logical=None, mutate_specs=None): + self.root = Path(tempfile.mkdtemp(prefix="o03-loader-control-")) + self.specs = {} + values = corpus() + self.logical = {} + for relative, original in zip(loader.INPUT_SPECS, values): + data = json.dumps(original, sort_keys=True, separators=(",", ":")).encode("ascii") + if logical and relative in logical: + data = logical[relative] + self.logical[relative] = data + packed = gzip.compress(data, mtime=0) if relative.endswith(".gz") else data + path = self.root / relative + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(packed) + path.chmod(0o444) + self.specs[relative] = {"encoding": "gzip" if relative.endswith(".gz") else "plain", + "transport_bytes": len(packed), "transport_sha256": hashlib.sha256(packed).hexdigest(), + "logical_bytes": len(data), "logical_sha256": hashlib.sha256(data).hexdigest()} + if mutate_specs: + mutate_specs(self) + for relative in reversed(loader.DIRECTORIES): + (self.root / relative).chmod(0o555) + self.root.chmod(0o555) + self.custody = self.snapshot() + + def snapshot(self): + return {"schema": "h25-input-custody-v1", "root": str(self.root), "root_identity": loader.identity(self.root.lstat()), + "directories": {p: loader.identity((self.root / p).lstat()) for p in loader.DIRECTORIES}, + "files": {p: dict(loader.identity((self.root / p).lstat(), True), sha256=s["transport_sha256"]) for p, s in self.specs.items()}} + + def load(self): + return loader._load(self.root, self.custody, self.specs, 3, 2) + + def close(self): + self.root.chmod(0o700) + for relative in loader.DIRECTORIES: + (self.root / relative).chmod(0o700) + shutil.rmtree(self.root) + + +def with_fixture(function, **kwargs): + fixture = Fixture(**kwargs) + try: + function(fixture) + finally: + fixture.close() + + +WITNESS = "baseline/evidence/canonical/witness.json.gz" + + +def valid_fresh(): + def check(f): + first, second = f.load(), f.load() + expected_witness = loader.restore_witness(corpus()[0]) + require(first["witness"] == expected_witness and first["ranks"] == [((3, 1), 2), ((5,), 1), ((3, 1), 2)], "finite exact tuple/order restoration") + require(first["result"]["labels"]["all_residuals_have_odd_vectors"] is False, "legitimate False") + require(type(first["result"]["circuit"]["roles_per_target"]) is float, "legitimate float") + first["witness"]["support"].append(77) + require(second["witness"] == expected_witness and first["result"] is not second["result"], "fresh ownership") + with_fixture(check) + + +def spec_failure(field, value, fragment): + def check(f): + f.specs[WITNESS][field] = value(f.specs[WITNESS][field]) + if field == "transport_sha256": + f.custody["files"][WITNESS]["sha256"] = f.specs[WITNESS][field] + rejects(f.load, loader.InputError, fragment) + with_fixture(check) + + +def invalid_gzip(truncated): + def prepare(f): + path = f.root / WITNESS + path.chmod(0o644) + data = path.read_bytes()[:-5] if truncated else b"not a gzip stream" + path.write_bytes(data) + path.chmod(0o444) + f.specs[WITNESS]["transport_bytes"] = len(data) + f.specs[WITNESS]["transport_sha256"] = hashlib.sha256(data).hexdigest() + with_fixture(lambda f: rejects(f.load, (OSError, EOFError)), mutate_specs=prepare) + + +def schema_mutation(mutate, message): + witness = corpus()[0] + mutate(witness) + rejects(lambda: loader.restore_witness(witness), loader.InputError, message) + + +def order_check(path, expected): + value = loader.restore_witness(corpus()[0]) + for key in path: + value = value[key] + require(value == expected, "retained order " + repr(path)) + + +def rank_bool(row): + value = [[[True] if row else [1], 1 if row else True]] + rejects(lambda: loader.restore_ranks(value, 1, 1), loader.InputError, "exact int") + + +def result_invalid(section, key, value, fragment): + certificate = corpus()[2] + certificate[section][key] = value + rejects(lambda: loader.restore_result(certificate), loader.InputError, fragment) + + +def decimal_error(): + limit = sys.get_int_max_str_digits() + require(limit > 0, "decimal conversion control requires unchanged positive interpreter limit") + rejects(lambda: loader.strict_json("1" * (limit + 1)), ValueError) + require(sys.get_int_max_str_digits() == limit, "integer limit mutated") + + +def wide_integer(): + value = 1 << 3000 + require(loader.strict_json(str(value)) == value, "arbitrary-width integer changed") + require(loader.restore_witness(corpus()[0])["support"][1] == 1 << 300, "wide tuple integer changed") + + +def mode_drift(): + def check(f): + f.load() + (f.root / WITNESS).chmod(0o644) + rejects(f.load, loader.InputError, "identity") + with_fixture(check) + + +def byte_drift(): + def check(f): + f.load() + path = f.root / WITNESS + path.chmod(0o644) + data = bytearray(path.read_bytes()) + data[-1] ^= 1 + path.write_bytes(data) + path.chmod(0o444) + rejects(f.load, loader.InputError, "identity") + # Freshly accepted metadata cannot hide changed bytes under old pins. + f.custody = f.snapshot() + rejects(f.load, loader.InputError, "transport hash") + with_fixture(check) + + +def in_call_drift(change_bytes): + def check(f): + original = loader.restore_result + def changed(certificate): + result = original(certificate) + path = f.root / WITNESS + path.chmod(0o644) + if change_bytes: + data = bytearray(path.read_bytes()) + data[-1] ^= 1 + path.write_bytes(data) + path.chmod(0o444) + return result + loader.restore_result = changed + try: + rejects(f.load, loader.InputError, "identity") + finally: + loader.restore_result = original + with_fixture(check) + + +def symlink_or_hardlink(symlink): + def check(f): + path = f.root / WITNESS + directory = path.parent + directory.chmod(0o755) + saved = directory / "saved-input" + path.rename(saved) + if symlink: + path.symlink_to(saved.name) + else: + os.link(saved, path) + directory.chmod(0o555) + rejects(f.load, loader.InputError) + with_fixture(check) + + +def logical_json_failure(data, exception, fragment=None): + with_fixture(lambda f: rejects(f.load, exception, fragment), logical={WITNESS: data}) + + +CONTROL_CASES = ( + ("L01_valid_schema_types_order_fresh_ownership", valid_fresh), + ("L02_transport_hash_before_decode", lambda: spec_failure("transport_sha256", lambda _: "0" * 64, "transport hash")), + ("L03_transport_size_before_decode", lambda: spec_failure("transport_bytes", lambda n: n + 1, "transport size")), + ("L04_invalid_gzip", lambda: invalid_gzip(False)), + ("L05_truncated_gzip", lambda: invalid_gzip(True)), + ("L06_logical_size_overrun", lambda: spec_failure("logical_bytes", lambda n: n - 1, "logical overrun")), + ("L07_logical_final_size_before_parse", lambda: spec_failure("logical_bytes", lambda n: n + 1, "logical size")), + ("L08_logical_digest_before_parse", lambda: spec_failure("logical_sha256", lambda _: "0" * 64, "logical hash")), + ("L09_duplicate_json_keys", lambda: logical_json_failure(b'{"x":1,"x":2}', loader.InputError, "duplicate")), + ("L10_nonfinite_json_nan", lambda: logical_json_failure(b'{"x":NaN}', loader.InputError, "nonfinite")), + ("L11_nonfinite_json_infinity", lambda: logical_json_failure(b'{"x":Infinity}', loader.InputError, "nonfinite")), + ("L12_wrong_witness_key_set", lambda: schema_mutation(lambda w: w.update(extra=[]), "exact keys")), + ("L13_wrong_code_key_set", lambda: schema_mutation(lambda w: w["code"].update(extra=[]), "exact keys")), + ("L14_unsupported_kind_leaf", lambda: schema_mutation(lambda w: w["kind"].__setitem__(1, []), "None or str")), + ("L15_args_arity", lambda: schema_mutation(lambda w: w["args"].__setitem__(2, [1]), "arity")), + ("L16_args_bool_int_rejected", lambda: schema_mutation(lambda w: w["args"].__setitem__(2, [True, 1]), "exact int")), + ("L17_label_bad_tag", lambda: schema_mutation(lambda w: w["labels"][1][0].__setitem__(0, "other"), "perp")), + ("L18_label_tag_arity", lambda: schema_mutation(lambda w: w["labels"][1].__setitem__(0, ["perp"]), "arity")), + ("L19_basis_order_retained", lambda: order_check(("labels", 0, 1), [(9, 17), (1, 3)])), + ("L20_gate_order_retained", lambda: order_check(("code", "gates"), [(2, (1, 0), (1, 2)), (1, (0,), (0, 1))])), + ("L21_source_order_retained", lambda: order_check(("code", "sources"), [((2, 0, 1), 2), ((1, 2, 3), 0)])), + ("L22_output_order_retained", lambda: order_check(("code", "outputs"), [(2, 1), (0, 2)])), + ("L23_arbitrary_width_ints", wide_integer), + ("L24_unchanged_decimal_error", decimal_error), + ("L25_duplicate_rank_events_retained", lambda: require(loader.restore_ranks(corpus()[1], 3, 2) == [((3, 1), 2), ((5,), 1), ((3, 1), 2)], "duplicate ranks lost")), + ("L26_rank_row_bool_rejected", lambda: rank_bool(True)), + ("L27_rank_result_bool_rejected", lambda: rank_bool(False)), + ("L28_result_int_bool_rejected", lambda: result_invalid("circuit", "h", True, "exact int")), + ("L29_result_float_not_int", lambda: result_invalid("circuit", "roles_per_target", 1, "finite float")), + ("L30_result_nonfinite_float_rejected", lambda: result_invalid("circuit", "roles_per_target", float("inf"), "finite float")), + ("L31_wrong_rank_count", lambda: rejects(lambda: loader.restore_ranks(corpus()[1], 4, 2), loader.InputError, "full event count")), + ("L32_wrong_distinct_count", lambda: rejects(lambda: loader.restore_ranks(corpus()[1], 3, 3), loader.InputError, "distinct row count")), + ("L33_mode_drift_no_cached_pass", mode_drift), + ("L34_byte_drift_no_cached_pass", byte_drift), + ("L35_symlink_rejected", lambda: symlink_or_hardlink(True)), + ("L36_hardlink_rejected", lambda: symlink_or_hardlink(False)), + ("L37_before_after_mode_drift", lambda: in_call_drift(False)), + ("L38_before_after_byte_drift", lambda: in_call_drift(True)), + ("L39_numeric_float_overflow", lambda: logical_json_failure(b'{"x":1e9999}', loader.InputError, "nonfinite")), +) + + +def run_controls(): + results = [] + for name, function in CONTROL_CASES: + function() + results.append({"name": name, "status": "PASS"}) + return {"schema": "h25-loader-controls-v1", "status": "LOADER_CONTROLS_PASS", "optimize": sys.flags.optimize, "count": len(results), "results": results} + + +if __name__ == "__main__": + print(json.dumps(run_controls(), sort_keys=True)) diff --git a/research/h25-authentic-serializer-20261031/provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json b/research/h25-authentic-serializer-20261031/provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json new file mode 100644 index 0000000000..4f28ce349e --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json @@ -0,0 +1,49 @@ +{ + "known_commit_provenance": { + "commit": "e05aad954689d0ee21baff19b4674f1fcb2e838f", + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/6029", + "repository": "CrocSwap/integer-mult-bounds", + "source": "control/PLAN-before-granular-progress-v1.md:7 identifies exact PR6029 package publication. Historical provenance only; upstream current existence/object readback pending." + }, + "method": "Stream named raw transport bytes in 1MiB blocks, no decompression, JSON parse or target code. Compute SHA256 and Git SHA1(blob NUL bytes); all current bytes match independently accepted feasibility pins.", + "network_performed": false, + "objects": [ + { + "bytes": 16995263, + "git_blob_sha1": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "git_mode": "100644", + "local_mode_octal": "0o664", + "local_path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "name": "witness.json.gz", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "transport_base64_characters": 22660352, + "upstream_repository_path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz" + }, + { + "bytes": 22029, + "git_blob_sha1": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "git_mode": "100644", + "local_mode_octal": "0o664", + "local_path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "name": "rank-trace.json.gz", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "transport_base64_characters": 29372, + "upstream_repository_path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz" + }, + { + "bytes": 5662, + "git_blob_sha1": "62a6091887a3894535c1d059e1b0c527d556eb76", + "git_mode": "100644", + "local_mode_octal": "0o664", + "local_path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "name": "complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "transport_base64_characters": 7552, + "upstream_repository_path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json" + } + ], + "parent_next_step": "Read exact repository tree/blob metadata at e05aad954689d0ee21baff19b4674f1fcb2e838f and current chosen upstream base; confirm SHA,size,mode. Existing verified blob IDs may be reused in create_tree without transferring base64 payload. Do not assume fork object availability absent confirmation.", + "remote_object_identity_verified_here": false, + "schema": "o03-authentic-transport-git-object-pins-v1", + "three_transport_bytes": 17022954 +} diff --git a/research/h25-authentic-serializer-20261031/provenance/feasibility/contract/DECISION-v1.json b/research/h25-authentic-serializer-20261031/provenance/feasibility/contract/DECISION-v1.json new file mode 100644 index 0000000000..ac2ae0ebb3 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/feasibility/contract/DECISION-v1.json @@ -0,0 +1,151 @@ +{ + "O03_achieved": false, + "activities": { + "PR_network_actions": 0, + "broad_census": 0, + "compiler_native_scientific_runs": 0, + "control_or_benchmark_runs": 0, + "payload_decompression": 0, + "payload_json_decode": 0, + "protected_runtime_runs_access": 0, + "target_execution": 0, + "target_imports": 0 + }, + "addendum_scope_tension": { + "citation": { + "lines": [ + 25, + 27 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/PLAN-v1.md", + "sha256": "84a282a6077af2a38ae33782f0d5c7b44febf3dbf347780601bb20b1192eba9d", + "source": "component_plan" + }, + "exact_text": "Complete original H25 artifact/caller claims require genuine complete caller evidence; a component fixture is not a substitute.", + "interpretation": "Preserve this prohibition on promoting fixture/replay evidence into genuine caller regeneration or complete original artifact/caller qualification. The frozen original O03 specifically asks serializer validation on complete artifacts; authentic retained-value replay is neither a finite substitute nor fresh scientific regeneration. Reading the addendum as a new universal fresh-construction prerequisite would broaden original O03/Area3, while current round expressly preserves their unchanged scope. This interpretation must be independently accepted; no credit is granted by interpretation alone.", + "precedence_test": [ + "Compare the exact O03 object/criterion and original Area3 clauses first; preserve every output/control/cost predicate.", + "Separate any fresh-generation/caller claim from complete-retained-value serializer behavior: the former requires genuine caller evidence, the latter is the proposed O03 evidence object.", + "Apply round PLAN lines3,11,13: preserve original scope, neither silently enlarge nor reduce requirements. If independent review finds line27 an irreconcilable governing fresh-caller prerequisite, keep CONDITIONAL and state that conflict; do not force GO." + ], + "round_citation": { + "lines": [ + 3, + 13 + ], + "path": "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/PLAN-v1.md", + "sha256": "ab2d7add19cf87e52d168e1536b722115ff5e23d9916155231bc45c64c2eaaf4", + "source": "round_plan" + } + }, + "answer": "Yes in principle: complete authentic retained-value serializer replay can satisfy unchanged O03, conditional on every Area3 output, boundedness, control, memory and cost predicate being executed and independently accepted. A successful source-only feasibility packet does not qualify O03.", + "created_utc": "2026-10-31T06:43:28.956812+00:00", + "criterion": "Bounded exact witness serialization validated on complete artifacts with memory/cost evidence", + "disposition": "CONDITIONAL", + "eager_replay_vs_historical_caller": { + "gain_boundary": "O03 requires validated bounded serialization and measured full-artifact memory/cost evidence. It does not explicitly require a total-process peak reduction or numerical speedup. A common eager-loader peak may hide writer savings; qualify only the measured bounded mechanism and disposition independently supported. No observed saving means NO_DEMONSTRATED_GAIN, never an inferred caller improvement; unexplained regression still requires assessment under original PLAN:74.", + "invalid_claim": "Original live circuit/check/code alias topology, native arithmetic correctness, historical construction memory, full caller peak/gain or closure of every caller output/check. An eager loader peak hiding writer savings is not itself proof of a measured full-process gain.", + "valid_claim": "Exact serialization behavior and measured memory/cost for fresh eager restored full retained H25 values under the declared replay consumer. Symmetric eager loading and separate writer-phase observations may diagnose serializer allocation; total process peaks remain reported." + }, + "execution_admitted": false, + "governing_citations": [ + { + "lines": [ + 27, + 31 + ], + "path": "outputs/h25-data-handling-20261028/control/hourly-progress/RUBRIC-v1.json", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1", + "source": "rubric" + }, + { + "lines": [ + 44, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 9, + 11 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 83, + 91 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + } + ], + "implementation_source_preparation": "GO", + "not_required_to_obtain_O03_alone": "Fresh scientific circuit construction, complete all-six integration, current native/FFI scientific profile qualification, all caller complement/typed-return/stdout checks, complete archive/publication closure are separately required original-goal obligations. A replay cannot award those milestones. No original O03/Area3 clause explicitly adds fresh scientific reconstruction as its prerequisite.", + "original_credit_awarded": false, + "passive_checks": { + "EXPECTED_equal_to_anchor_side_fields": true, + "EXPECTED_literal_equal_to_original": true, + "all_selected_python_sources_parse": true, + "control_list_count_matches_70": true, + "current_plan_preserves_complete_original_plan_prefix": true, + "literal_original_canonical_source_equal": true, + "literal_original_writer_source_equal": true, + "manifest_rank_logical_matches_EXPECTED": true, + "manifest_witness_logical_matches_EXPECTED": true, + "original_O03_criterion_unchanged": true + }, + "resource_disposition": "Unknown fit is conditional, not demonstrated impossibility. No file-size-only GO, no new runtime budget and no implementation/execution extension.", + "schema": "h25-o03-original-contract-feasibility-decision-v1", + "separate_gates": [ + { + "criterion": "Construction union/index-lifetime improvement validated on the complete caller with memory/cost evidence", + "id": "O02" + }, + { + "criterion": "Current integrated source/ownership/runtime prerequisites and complete old/new control union passed", + "id": "O07" + }, + { + "criterion": "Complete assertion-on baseline/candidate caller reproduces every required exact output and check", + "id": "O08" + }, + { + "criterion": "Complete wall/CPU/peak-memory/archive costs and reproducible gain or final measured dispositions established", + "id": "O09" + }, + { + "criterion": "Reproducible Git-free export and scoped upstream publication, exact-head hosted checks and readbacks complete", + "id": "O10" + }, + { + "criterion": "All six current implementation contracts closed, including cache validity and automatic retention", + "id": "S03" + }, + { + "criterion": "All required current bootstrap, owner, native, FFI and runtime profiles qualified", + "id": "S06" + }, + { + "criterion": "Complete current combined stage, source bindings and caller assembly independently accepted", + "id": "S07" + }, + { + "criterion": "Full assertion-on comparison caller and fixed measurement/resource protocol admitted", + "id": "S10" + } + ], + "smallest_missing_predicates": [ + "P1: Implement and independently accept isolated fixed-pin full-input loader plus fresh baseline/candidate consumer and concrete loader/consumer controls; keep original reference, EXPECTED and70 ordered cases unchanged.", + "P2: Fresh immutable source/input/runtime custody and parent serialized exact operation/resource/budget admission; no execution is authorized by this round.", + "P3: Execute all genuine schema/type/tuple/order checks and require complete output/receipt equality, production fast-path with faults false, original error/write controls and new loader controls.", + "P4: Observe full-artifact bounded serializer behavior, measured complete replay process-tree peak RSS and inclusive wall/CPU costs under180seconds/1GiB limits, fixed schedule/no reroll, accounting for eager loader allocations and extra copies/hashes. Attribute writer phases and report any NO_DEMONSTRATED_GAIN disposition; original O03/Area3 contain no numerical decrease threshold.", + "P5: Independently accept finite inclusive validation/cleanup/finalization measurement endpoint with explicitly reported outside tail; retain historical/F7 gaps and no whole-caller or original-total claim." + ] +} diff --git a/research/h25-authentic-serializer-20261031/provenance/feasibility/contract/O03-MATRIX-v1.json b/research/h25-authentic-serializer-20261031/provenance/feasibility/contract/O03-MATRIX-v1.json new file mode 100644 index 0000000000..9eb362b236 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/feasibility/contract/O03-MATRIX-v1.json @@ -0,0 +1,385 @@ +{ + "created_utc": "2026-10-31T06:43:28.956812+00:00", + "original_weights_and_denominators_changed": false, + "rows": [ + { + "citations": [ + { + "lines": [ + 27, + 31 + ], + "path": "outputs/h25-data-handling-20261028/control/hourly-progress/RUBRIC-v1.json", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1", + "source": "rubric" + }, + { + "lines": [ + 44, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 31, + 43 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "source": "manifest" + }, + { + "lines": [ + 1, + 1 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "source": "anchor" + } + ], + "currently_qualifies": false, + "id": "C01", + "original_obligation": "Complete authentic artifacts, not an enlarged finite fixture", + "passive_evidence": "Manifest/anchor/unchanged EXPECTED agree on full witness, rank and result; logical content is not decoded in this lane.", + "prospective_fail_condition": "Any truncation, repeated synthetic substitute, missing event, output/receipt mismatch, saved PASS or candidate-derived EXPECTED.", + "prospective_pass_predicate": "Authenticate complete retained transports/logical bytes, restore every genuine value afresh per arm; both arms reproduce result527+witness58143622+rank2674272 bytes and all five EXPECTED fields." + }, + { + "citations": [ + { + "lines": [ + 46, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 17, + 47 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968", + "source": "reference" + }, + { + "lines": [ + 322, + 333 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/integration/full_driver.py", + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "source": "observer" + }, + { + "lines": [ + 32, + 57 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source": "circuit" + }, + { + "lines": [ + 219, + 223 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source": "circuit" + }, + { + "lines": [ + 271, + 294 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source": "circuit" + }, + { + "lines": [ + 351, + 373 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "source": "circuit" + } + ], + "currently_qualifies": false, + "id": "C02", + "original_obligation": "Exact sorted-key ASCII schema, arbitrary integer representation and ordered collections", + "passive_evidence": "Literal canonical/writer extraction and EXPECTED equal originals by passive AST/source comparison. Tuple restoration schema is source supported.", + "prospective_fail_condition": "Schema normalization, bool admitted where int required, changed error/conversion semantics, reordered/deduplicated observations or only hash-equivalent unsupported representation.", + "prospective_pass_predicate": "New loader validates exact builtin types/arity/tagged alternatives and restores source tuple positions; retain order in basis/items/gates/sources/outputs/rank including duplicates without sorting. Original receipt requires59959 events and252 distinct row tuples." + }, + { + "citations": [ + { + "lines": [ + 9, + 11 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 46, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 42, + 122 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "source": "candidate" + }, + { + "lines": [ + 295, + 356 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "source": "candidate" + } + ], + "currently_qualifies": false, + "id": "C03", + "original_obligation": "Bounded serializer in actual consuming path with independent unchanged reference", + "passive_evidence": "Candidate source chunks C-backed canonical batches, caps rows/bytes and falls back outside its exact-container/per-record bound. No genuine record admission executed.", + "prospective_fail_condition": "Fallback measured as bounded improvement, synthetic reference EXPECTED, shared mutable answer or only unused helper source.", + "prospective_pass_predicate": "Independent fresh processes/owned inputs call literal baseline and production make_writer; fault seam false; genuine candidate status BOUNDED_SERIALIZATION_PASS with batch/copy bounds and complete source/runtime freshness." + }, + { + "citations": [ + { + "lines": [ + 48, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 74, + 93 + ], + "path": "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "source": "original_writer" + }, + { + "lines": [ + 380, + 497 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "source": "candidate" + } + ], + "currently_qualifies": false, + "id": "C04", + "original_obligation": "Private staging; final names after all encoding and expected checks; preserve partial-write rejection/error semantics", + "passive_evidence": "Original validates complete receipt before sequential result,witness,rank writes. Candidate stages/hash-checks all before same-order final copies; successful cleanup precedes PASS. It does not promise all-or-nothing final triplet on later I/O failure.", + "prospective_fail_condition": "Premature final exposure, hidden partial writes, retry after short writes, erased failed evidence or unsupported stronger atomicity claim.", + "prospective_pass_predicate": "Execute retained source-bound negative controls and new consumer controls for mismatches, conversion/IO/close/copy/cleanup failure; verify no finals before acceptance, later partial finals/error evidence reflect declared original behavior, primary exception retained." + }, + { + "citations": [ + { + "lines": [ + 48, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 2, + 6 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423", + "source": "controls" + }, + { + "lines": [ + 18, + 93 + ], + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423", + "source": "controls" + }, + { + "lines": [ + 45, + 70 + ], + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/NEXT-SOURCE-v1.md", + "sha256": "f4d3ae05e4e36f2b55894202a79968666b6ce5255daca45c6283387713f903c9", + "source": "next_source" + } + ], + "currently_qualifies": false, + "id": "C05", + "original_obligation": "Unicode, escaping, wide integers, types, ordering, boundaries, malformed values, conversion exceptions and partial-write cleanup controls", + "passive_evidence": "70 exact old cases per mode cover named families; existing spec explicitly disclaims exhaustive cross-products. New loader/consumer suite is prospective, not implemented.", + "prospective_fail_condition": "Prose cases counted as executed, changed literal oracles, absent loader negative controls, or stale source evidence reused across changed closure.", + "prospective_pass_predicate": "Preserve all70 ordered controls with independent literal oracles in normal/-O modes and independently freeze/execute concrete new loader/custody/schema/consumer controls; map actual cases to each Area3 family, report remaining limitations." + }, + { + "citations": [ + { + "lines": [ + 46, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 74, + 74 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 85, + 87 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 19, + 60 + ], + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/INPUT-BILL-v1.json", + "sha256": "a41c28cf1ae2a2517c38589625c55f9df9a6634fa4f0a288882afe7597d67fac", + "source": "input_bill" + } + ], + "currently_qualifies": false, + "id": "C06", + "original_obligation": "Measured complete serialization memory/cost evidence, buffers/conversion/hash/writes/controls/cleanup charged", + "passive_evidence": "Known bytes/batch caps are not a RAM or speed proof. Candidate adds full staging/copy/hash pass; loader can hold decoded and restored inputs simultaneously.", + "prospective_fail_condition": "1MiB buffers/file sizes substituted for RSS; eager parse peak omitted; candidate fallback; unexplained regression; omitted validation/cleanup/tail charged zero;180s/1GiB breach.", + "prospective_pass_predicate": "Fixed first baseline/candidate schedule; inclusive wall, aggregate child CPU, sampled/kernel memory with limitations; input staging/import/auth/decode/parse/restoration, all controls, writers, full validation/readback/cleanup and admitted closing protocol measured. Validate bounded actual serializer behavior on complete artifacts and measured peak RSS; independently assess costs/slowdowns and report any NO_DEMONSTRATED_GAIN. Original O03/Area3 specify no numerical speedup or total-process RSS decrease threshold; shared loader peaks must not be mislabeled as writer gain." + }, + { + "citations": [ + { + "lines": [ + 9, + 11 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 26, + 28 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 35, + 43 + ], + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/NEXT-SOURCE-v1.md", + "sha256": "f4d3ae05e4e36f2b55894202a79968666b6ce5255daca45c6283387713f903c9", + "source": "next_source" + }, + { + "lines": [ + 19, + 34 + ], + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/INPUT-BILL-v1.json", + "sha256": "a41c28cf1ae2a2517c38589625c55f9df9a6634fa4f0a288882afe7597d67fac", + "source": "input_bill" + } + ], + "currently_qualifies": false, + "id": "C07", + "original_obligation": "Preserve source/ownership/call coverage/fallback freshness and input independence", + "passive_evidence": "Canonical JSON cannot recover old object aliases, allocation topology or sorted-away dict insertion order. For exact immutable builtin values and read-only canonical traversal, those lost facts do not alter serialized bytes; rank row tuple hashability and ordered list events do matter.", + "prospective_fail_condition": "Claim historical alias/caller peak or new scientific call coverage; hidden mutable sharing, callback-bearing input, source/runtime drift or mode mismatch accepted.", + "prospective_pass_predicate": "Fresh schema-restored inputs per arm, exact callable/runtime/stdlib gzip-zlib/_json/hash closure, immutable staged pins and before/after custody, representative loader error controls; retain alias/callback fallback controls. State replay ownership and RSS topology scope accurately." + }, + { + "citations": [ + { + "lines": [ + 48, + 48 + ], + "path": "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e", + "source": "original_plan" + }, + { + "lines": [ + 49, + 60 + ], + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/INPUT-BILL-v1.json", + "sha256": "a41c28cf1ae2a2517c38589625c55f9df9a6634fa4f0a288882afe7597d67fac", + "source": "input_bill" + }, + { + "lines": [ + 348, + 356 + ], + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/review/SERIALIZER-FEASIBILITY-REVIEW-v1.json", + "sha256": "7627f233cc6c1e1f34e08bc1529056529d6a95a47e10b32bbf6e8c9de4554b7b", + "source": "prior_review" + } + ], + "currently_qualifies": false, + "id": "C08", + "original_obligation": "Finite cost boundary and honest final tail", + "passive_evidence": "No measured physical tail closure occurs here. Prior F7 and historical total gaps remain OPEN_NOT_ZERO.", + "prospective_fail_condition": "Retrospective endpoint selection, recursive final report cost silently zero, skipped cleanup/validation, or replay used to erase old F7/O09 timing gaps.", + "prospective_pass_predicate": "Before execution, freeze finite outer start/end that includes all required serializer operation work, failure/cleanup/readback and meter/receipt finalization that can be included. List any final observer/report self-publication and source-review/staging/publication outside costs separately as measured/unknown; O03 acceptance must not omit required serializer work or imply complete original-goal cost closure." + } + ], + "schema": "h25-o03-original-obligation-matrix-v1", + "status": "SOURCE_CONTRACT_ONLY_NO_RUNTIME_CREDIT" +} diff --git a/research/h25-authentic-serializer-20261031/provenance/feasibility/review/REVIEW-v1.json b/research/h25-authentic-serializer-20261031/provenance/feasibility/review/REVIEW-v1.json new file mode 100644 index 0000000000..c84f737f31 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/feasibility/review/REVIEW-v1.json @@ -0,0 +1,103 @@ +{ + "accepted_feasibility_packet": true, + "activity_boundary": { + "decompressions": 0, + "further_agents": 0, + "method": "Exact named source/text/metadata reads, SHA256 and passive AST/symbolic analysis only.", + "native_compiler_scientific": 0, + "network_PR_actions": 0, + "payload_decodes": 0, + "protected_runs_access": 0, + "target_function_calls": 0, + "target_imports": 0, + "tests_controls_benchmarks": 0 + }, + "answer": "Authentic complete retained-value replay is a source-supported route capable of qualifying unchanged O03 without cache/retention or new scientific construction. Actual qualification is conditional on the concrete source, custody, controls, full-data fast path and measured inclusive memory/cost evidence below. No source impossibility counterexample was established; resource fit remains unproved.", + "created_utc": "2026-10-31T06:48:26.591748+00:00", + "credit": { + "O03_achieved": false, + "complete_caller": false, + "denominators_weights_changed": false, + "historical_cost_gap_closed": false, + "original_six_area_goal_complete": false, + "runtime_budget_created": false, + "serializer_runtime_or_F7_new_credit": false + }, + "decision": "CONDITIONAL_SPECIFIC_PREREQUISITES", + "evidence_invalidation": "Any changed source/packet/input/runtime binding invalidates dependent acceptance; current mutable-file hashes are readbacks at this review time, not future custody guarantees.", + "evidence_manifest": "EVIDENCE-PINS-v1.json", + "execution_admitted": false, + "implementation_performed_here": false, + "independent_readbacks": { + "all_mismatches": 0, + "contract_sources_exact": 22, + "passive_predicates_are_serializer_execution": false, + "reviewer_literal_reference_AST_matches": true, + "technical_helper_failure_retained": "PASSIVE-ATTEMPTS-v1.json KeyError bytes before repaired metadata-only check; no target work.", + "technical_package_members_exact": 7, + "technical_passive_predicates": 50, + "technical_sources_exact": 52 + }, + "isolated_qualifying_source_preparation": "GO", + "measurement_boundary": { + "gain_scope": "No invented numerical speedup or total-RSS reduction threshold in original O03/Area3. A common loader peak can mask writer savings. Bounded behavior plus complete measured memory/cost and supported NO_DEMONSTRATED_GAIN/regression disposition may qualify O03; never infer an original-caller saving or waive global O09 obligations.", + "included": "Transport re-reads; bounded decompression/logical authentication; strict parse/restoration and simultaneous containers; runtime/source checks; baseline complete encodings; candidate factory/preflight/repeated bounds/batch slices/Unicode/ASCII/hash/staging/copy/freshness; rank set; all writes/control failures; local streaming readback; independent complete comparison and parent guard/log/custody readbacks; success/failure cleanup and declared closing records.", + "inclusive_start": "Before operation source/runtime authentication, immutable input staging, imports, controls and loader allocation.", + "memory": "Observe replay parent and all concurrent descendants throughout fixed serial lifetimes. Report sampled simultaneous group RSS, sampling/PID limitations, individual kernel maxRSS and any cgroup peak with definitions separately. GNU process maxRSS or sum of nonconcurrent individual maxima is not aggregate concurrent peak. Include eager loader peak; writer-phase attribution supplements inclusive observations.", + "outside_tail": "Predeclare final observer measurement-record write and one parent readback/publication as finite explicit outside overhead if unavoidable; keep actual known/unknown OPEN_NOT_ZERO. All substantive serializer/control/validation/cleanup work must remain inside. This does not close historical gaps, old F7 physical tail or whole-goal costs.", + "resource_unknowns": "No genuine per-record size/depth/type admission, actual full-data batch count, JSON/restoration liveness, wall/CPU/peak or180s/1GiB fit was tested.1MiB buffers and60818421 output bytes prove neither fit nor gain.", + "symbolic_costs": "Baseline writes/hashes60818421bytes. Candidate stages60818421, copy-reads60818421, writes final60818421 and hashes two full passes121636842; candidate total writer writes121636842. Independent validations/input/runtime/control/metadata/failure work are additional. technical/PROBE-SPEC-v1.json exact bill retained." + }, + "original_scope": { + "authoritative_original_sources": [ + "control/hourly-progress/RUBRIC-v1.json:27-31", + "control/PLAN-before-granular-progress-v1.md:9-11,44-48,83-91" + ], + "complete_evidence_object": "Full527-byte result projection,58143622-byte witness and2674272-byte ordered rank trace;60818421 output bytes,59959 rank events,252 distinct row tuples; original five-field EXPECTED unchanged.", + "criterion": "Bounded exact witness serialization validated on complete artifacts with memory/cost evidence", + "independent_reference": "Reviewer passive AST equality separately confirmed canonical and write_scientific equal frozen originals. Fresh separate processes/owned restored inputs and fixed independent EXPECTED prevent candidate self-oracles.", + "matrix_accepted": "contract/O03-MATRIX-v1.json C01-C08, every original output/reference/control/failure/boundedness/memory/cost predicate retained", + "separate_original_obligations": "O02 complete construction caller; O07 current combined integration/control closure; O08 complete assertion-on caller; O09 complete all-area costs/gain/dispositions; O10 export/upstream/hosted checks. All remain open; O03 does not silently inherit their entire scope." + }, + "prospective_pass_fail": { + "eligible_O03_review": "All Q1-Q5 and technical P0-P5 pass; entire authentic full input, production bounded fast path, exact old/new error contract and complete independently accepted resource evidence.", + "fixed_route_failure": "Any genuine schema/tuple/order/EXPECTED mismatch, unsupported row/depth triggering fallback, actual control/custody/runtime drift, premature final exposure, hidden cleanup/failure, or resource-cap violation stops and preserves this fixed operation. No smaller/synthetic input substitution and no saved PASS. A source repair needs new review/admission.", + "not_universal_impossibility": "A cap/fallback failure would reject that fixed implementation/operation, not prove all exact serializers impossible. None occurred in this source-only round." + }, + "reviewer": "serializer_o03_review", + "schema": "h25-o03-independent-feasibility-adjudication-v1", + "scope_tension_retained_and_resolved": { + "exact_text": "Complete original H25 artifact/caller claims require genuine complete caller evidence; a component fixture is not a substitute.", + "independent_resolution": "This authored stream planning phrase preserves the prohibition on claiming fresh original caller generation/qualification from a component fixture or replay. The unchanged original O03 evidence object is exact serialization validated on complete artifacts; its Area3 clauses do not require fresh construction. O02/O08 expressly require the caller. The round explicitly prohibits adding unrelated caller/O09/O10 obligations. I accept the contract lane distinction: authentic complete retained-value serialization can satisfy O03 while fresh original caller/artifact-generation claims stay prohibited. This is an explicit scope interpretation, not replacement of the user goal or relaxation of any Area3 predicate.", + "lane_disagreements": "No unresolved disagreement between frozen contract and technical packets. Their conditional qualification/source-preparation GO dispositions agree.", + "rejected_reading": "Treating the slash phrase as a universal fresh-caller prerequisite for every serializer-on-retained-values claim would add scope absent original O03/Area3. No independent exact original dependency supporting that reading was identified.", + "source": "streams/independent-components-20261031/PLAN-v1.md:27" + }, + "specific_prerequisites_in_order": [ + { + "id": "Q1", + "now": "MISSING_SOURCE", + "required": "Author and independently accept isolated fixed-pin bounded-gzip/strict-JSON/schema-restoration loader, complete genuine separate-process consumer and concrete ordered loader/consumer controls. Reuse exact reference/candidate and70 old cases per mode; old finite2048-row consumer cannot qualify genuine H25 unchanged. Preserve legitimate result bool/finite roles_per_target float; reject bool only at exact-int positions." + }, + { + "id": "Q2", + "now": "PARTIAL_IDENTITIES_ONLY_NO_CUSTODY_OR_TARGET_RUNTIME_ADMISSION", + "required": "Create separately owned immutable regular input/source copies and independently seal actual loader/consumer/controls/bootstrap/import/callable/binary/shared-library/guard/sampler/validator closure. Include gzip and actual interpreter built-in zlib provider plus linked libz, _json and selected hash implementations, conditional dependencies and effective before/after bindings. Current0664 mirror bytes match old0444 pins but do not establish old custody. Preserve mirror and reject aliases/symlinks/drift." + }, + { + "id": "Q3", + "now": "NO_EXECUTION_ADMISSION", + "required": "Parent independently admits fixed P0-P5 operation from technical/PROBE-SPEC-v1.json under current canonical ledger, serialized guard,180s per command and sampled1GiB cap within existing2400s allowance. All failures/control/observer costs charged; no retry/reroll/resizing/new budget.94.210533479 setup policy seconds is historical and must refresh." + }, + { + "id": "Q4", + "now": "GENUINE_SCHEMA_RECORD_ELIGIBILITY_AND_ALL_DYNAMIC_PREDICATES_UNTESTED", + "required": "Execute exact old normal/-O controls and newly frozen loader/consumer/observer controls, then one optimization0 full baseline and one optimization0 full candidate on fresh inputs, followed by independent bounded complete byte/receipt/custody comparison. Require faults false, BOUNDED_SERIALIZATION_PASS, complete original EXPECTED/sizes/order/tuple/count equality, private staging/final failure semantics and successful cleanup. Preserve every failure." + }, + { + "id": "Q5", + "now": "UNMEASURED_180S_1GIB_FIT_UNKNOWN", + "required": "Before execution, accept finite inclusive process-tree observation/validation/cleanup endpoint and explicit outside tail; afterward independently accept actual bounded serializer/full-artifact memory-cost evidence and honest gain/no-gain/regression disposition." + } + ] +} diff --git a/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/FEASIBILITY-v1.json b/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/FEASIBILITY-v1.json new file mode 100644 index 0000000000..5aace52e8d --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/FEASIBILITY-v1.json @@ -0,0 +1,166 @@ +{ + "actual_input_contract": { + "full_expected": { + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c" + }, + "metadata": [ + "baseline/evidence/canonical/MANIFEST.json", + "baseline/anchor.json", + "STAGE.json" + ], + "required_transports": [ + "baseline/evidence/canonical/witness.json.gz", + "baseline/evidence/canonical/rank-trace.json.gz", + "baseline/evidence/canonical/complex-network.json" + ], + "sizes": { + "artifact_total": 60818421, + "rank_trace": 2674272, + "result": 527, + "three_logical_inputs_before_result_projection": 60823556, + "three_transport_files": 17022954, + "witness": 58143622 + }, + "source_supported_restore": { + "code": "Exact dict roles:int,gates:list[tuple[int,tuple[int,...],tuple[int,...]]],sources:list[tuple[tuple[int,int,int],int]],outputs:list[tuple[int,int]].", + "labels": "list[tuple[int|tuple[str-perp,tuple[int,int,int]],list[tuple[int,int]],int,tuple[int,...]]]; preserve cache/basis/key order.", + "pieces": "list[tuple[tuple[int,int,int],int,tuple[int,int]]] with coefficient numerator/denominator; no Fraction reconstruction.", + "rank": "list[tuple[tuple[int,...],int]], all59959 events including duplicates, in original order; original distinct-row set must equal252.", + "result": "Project exactly circuit,side_map,labels,role_frames from certificate. Preserve source-declared booleans, strings and circuit.roles_per_target finite float; do not blanket-reject result bool/float or cast float to int. Reject bool only at exact-int schema positions.", + "witness": "Exact dict support,args,kind,active,pieces,labels,code. support:list[int]; args:list[None|tuple[int,int]]; kind:list[None|str]; active:list[int] in retained order." + }, + "validation_gap": "Payloads were transport-hashed only. No compressed JSON or plain certificate was parsed in this lane. Logical hashes, shapes and counts remain metadata assertions until a separately admitted actual loader validates every record. Tuples can be restored from source; historical aliases/allocation topology/dict order erased by canonical sorting cannot be recovered or claimed." + }, + "allowed_activity_counts": { + "decompressions": 0, + "dynamic_controls": 0, + "fixed_source_transport_partial_runtime_paths_pinned": 52, + "measurements": 0, + "network_actions": 0, + "passive_source_metadata_predicates_passed": 50, + "payload_decodes": 0, + "protected_runs_access": 0, + "scientific_runs": 0, + "target_function_calls": 0, + "target_imports": 0 + }, + "candidate_fast_path": { + "actual_full_data_status": "UNTESTED: byte count60818421 and1MiB configured buffers prove neither fast-path eligibility nor1GiB/180s fit.", + "fallback": "Any unsupported preflight/path delegates literal reference with LITERAL_REFERENCE_FALLBACK; same final digests then do not establish genuine bounded-path admission. A genuine record over the conservative1MiB bound would fail this route despite total payload size. No such record is known from passive inspection.", + "integer_bound": "int.bit_length(value)*30103//100000+2; strings12*len(value)+2; recursive sequence/dict bounds are deliberately conservative.", + "requirements": [ + "Exact built-in dictionaries/key sets; list/tuple admitted arrays; exact int code.roles", + "Every result bound<=1048576; every array item recursive bound+3<=1048576; recursion depth<32 and no cycle/unsupported leaf", + "Rank outer list, tuple events length2, tuple rows of exact ints and exact int rank", + "Exact local Path, regular fresh destination, no live concurrent mutation", + "make_writer faults disabled, unchanged effective reference/JSON/_json/hashlib/expected runtime bindings at entry and success exit", + "Every complete receipt field matches unchanged full EXPECTED; all3 copied digests/counts match staged acceptance; stages removed on success" + ] + }, + "conclusion": "Authentic full frozen-value replay is a source-constructible independent O03 route without resuming paused cache/retention or constructing new scientific values. Actual schema admission, candidate fast path, resource fit and memory/cost evidence remain untested. No impossibility counterexample is established.", + "current_credit": { + "O03": false, + "all_six_areas": false, + "gain": false, + "historical_cost_gap_closed": false, + "whole_caller": false + }, + "custody": { + "byte_hash_match": true, + "current_mirror_inputs": "0664", + "old_mode_custody_equality": false, + "old_stage_inputs": "0444", + "required": "Preserve mirror files. Parent creates separately owned immutable regular copies, records fixed paths/modes/source/transport hashes and before/after identities; no writable aliases, symlinks or unbilled staging. A new isolated replay ownership contract must be independently accepted." + }, + "disposition": "CONDITIONAL_GO_FOR_ISOLATED_SOURCE_PREPARATION; QUALIFYING_EXECUTION_NOT_ADMITTED", + "evidence": [ + "PASSIVE-CHECKS-v1.json", + "SOURCE-PINS-v1.json", + "PROBE-SPEC-v1.json", + "PASSIVE-ATTEMPTS-v1.json" + ], + "memory_and_time": { + "caps": { + "existing_total_policy_seconds": 2400, + "live_ledger_refresh_required": true, + "new_budget": false, + "per_command_wall_seconds": 180, + "sampled_group_memory_bytes": 1073741824, + "setup_historical_policy_usage_seconds": "94.210533479" + }, + "fit": "UNKNOWN, no static proof or dynamic measurement", + "observer": "Measure parent and all concurrent descendants, with fixed sequential arm lifetimes and one guard. GNU time/wait4 individual-process maxRSS is not simultaneous aggregate process-tree peak. Report per-process kernel high-water values and sampled simultaneous group RSS separately; expose sampling interval, PID membership/race limitations and any independent cgroup peak with its cache/RSS definition.", + "qualification": "Require actual full-process and writer-phase memory/cost evidence plus successful bounded behavior and complete equality. No invented percentage or mandatory total-RSS reduction; masked/no gain or regression must be reported and independently dispositioned, never called a measured saving.", + "scope": "Replay peak is evidence for the concrete replay, never original caller RSS or historical alias topology. Common loader peak may dominate both arms and hide a serialization-phase reduction.", + "simultaneously_live_terms": [ + "runtime/guard/sampler/parent validator", + "compressed buffers and gzip/zlib state", + "logical byte buffers plus JSON Unicode text", + "decoded JSON lists/dicts/ints/strings plus restored tuple containers during transition", + "complete eager replay result/witness/ranks", + "original distinct-row set and equality/readback state", + "baseline3 retained complete encodings including witness58MB", + "candidate full preflight and repeated row bounds, batch slice/Unicode/ASCII/views, hashing/staging/copy buffers", + "all control/receipt/failure/log/cleanup allocations" + ] + }, + "original_O03": "Bounded exact witness serialization validated on complete artifacts with memory/cost evidence", + "other_goal_boundaries": "No cache validity/retention implementation, full scientific reconstruction, original caller integration, all-six checks or closure of unrelated O09/O10 is required merely to prepare this O03 replay route. Whole-goal/O07/O08/O09/O10 and historic physical-cost obligations remain separate and open.", + "parent_admission": "Independent review of exact new source/case order/closure/custody/probe and finite observer tail; canonical ledger/resource admission in parent serialized guard. Only then may dynamic decision probes run. This packet grants none.", + "runtime_closure": { + "admission_required": "Exact source and every actual imported module/binary/shared-library dependency including bootstrap/site policy, stdlib transitive imports, hash implementation selection/fallbacks, controls normal/-O, guard, sampler and independent validation. Seal actual effective bindings before/after; reject unexpected imports, source/mode/linkage drift or target/scientific modules. Existing writer freshness covers selected JSON/reference bindings, not all gzip/loader/observer custody.", + "gzip_zlib_identity": "Passive interpreter is /usr/bin/python3.12 (SHA256 in SOURCE-PINS); zlib is listed among its built-in modules. gzip.py/_compression.py/struct.py and mapped /usr/lib/x86_64-linux-gnu/libz.so.1.3 are pinned separately. No zlib import/version probe was executed. Built-in provider identity requires interpreter custody plus linked libz, not a fictitious separate zlib extension.", + "new_loader_required_union": [ + "gzip", + "zlib", + "_compression", + "io", + "struct", + "builtins", + "os", + "sys", + "time plus all actual conditional/transitive branches" + ], + "other_partial_identity": "Actual metadata-process _json and _hashlib extensions, libcrypto.so.3 and JSON/hashlib source are pinned, without claiming these are a future admitted target runtime.", + "pinned_actual_component_direct_import_union": [ + "__future__", + "_json", + "argparse", + "bounded_serialization", + "contextlib", + "copy", + "hashlib", + "json", + "json.encoder", + "os", + "pathlib", + "reference", + "serialization_controls", + "stat", + "sys", + "tempfile", + "types" + ], + "status": "OPEN_REQUIRED_BEFORE_EXECUTION; cannot seal closure of unimplemented loader/consumer/observer now" + }, + "schema": "o03-technical-source-and-probe-feasibility-v1", + "source_route": { + "independence": "Each arm owns newly decoded/restored exact built-ins, independent fresh process/root and no saved PASS. Candidate uses the literal unchanged baseline reference; its complete EXPECTED is never replaced by candidate-derived hashes. Canonical metadata authenticates retained values, not a fresh mathematical reconstruction.", + "new_source_required": [ + "frozen_h25_inputs.py: fixed transport authentication, bounded gzip, logical authentication, strict JSON and source-schema restoration", + "representative_consumer.py: fresh complete genuine input in each separate arm; full EXPECTED; candidate fast-path enforcement", + "frozen_input_controls.py: independently frozen ordered loader/consumer positive and rejection cases", + "parent sealed adapter/jobs/guard and process-tree observer plus independent output/custody validator" + ], + "not_existing": "The old component_consumer.py is finite-only: it constructs2048 synthetic support rows and finite EXPECTED. It cannot qualify this genuine route unchanged. Its read_bytes local output validation would allocate a58MB witness; use fixed bounded streaming validation in new source and bill it.", + "reuse_unchanged": [ + "reference.py: canonical/write_scientific/EXPECTED/require", + "bounded_serialization.py: make_writer", + "serialization_controls.py and CONTROL-SPEC.json: original70-case normal/-O suite" + ] + } +} diff --git a/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/PROBE-SPEC-v1.json b/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/PROBE-SPEC-v1.json new file mode 100644 index 0000000000..eb71ccf046 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/PROBE-SPEC-v1.json @@ -0,0 +1,137 @@ +{ + "decision_operation": "After source/custody/control admission, fixed first original complete replay followed by fixed first candidate complete replay, fresh process/root/input instances. No separate speculative stress probe, scientific reconstruction or cache/retention integration is needed. Controls and independent validation are mandatory paid parts of the operation.", + "fixed_sequence": [ + { + "fail": "Stop; retain mismatch evidence; no target run", + "id": "P0", + "operation": "Before-custody/staging/authentication and immutable source/runtime seal", + "pass": "All exact paths, bytes, modes, identities and actual closure match; no unexpected modules, aliases or cached PASS" + }, + { + "fail": "Stop complete pair; retain all files/failures and charged costs", + "id": "P1", + "operation": "Unchanged70 original finite cases in normal and -O plus implemented independently frozen loader/consumer controls in both modes; observer controls in parent guard", + "pass": "Concrete ordered counts/results match accepted source; all old error/fallback cases remain visible; new strict loader controls pass" + }, + { + "fail": "Stop; invalid source/input/cap outcome is evidence, never repaired by changing EXPECTED", + "id": "P2", + "operation": "One optimization0 original write_scientific replay, complete authentic fresh decoded/restored inputs", + "pass": "All3 original EXPECTED hashes, exact sizes,59959 events and252 distinct rows; baseline local bounded readback; no source/runtime drift" + }, + { + "fail": "Fallback is unsupported genuine bounded route; error/cap retains evidence; no reroll or smaller replacement input", + "id": "P3", + "operation": "One optimization0 candidate make_writer replay on independent complete fresh input", + "pass": "Full original receipt/size equality, faults false, BOUNDED_SERIALIZATION_PASS, actual row/batch/copy counters within declared limits, expected success cleanup and unchanged closure" + }, + { + "fail": "Stop; preserve first discrepancy and all raw evidence", + "id": "P4", + "operation": "Separate parent-owned fixed bounded streaming comparison and after-custody/cleanup validation", + "pass": "All3 baseline and candidate bytes mutually equal and agree with freshly authenticated frozen logical witness/rank bytes;527-byte result projection independently agrees with literal original canonical/EXPECTED; all expected receipts, output sizes and cleanup states match" + }, + { + "fail": "O03 remains open; do not reinterpret source/passive checks as runtime validation", + "id": "P5", + "operation": "Close declared evidence/logs; parent validates observer/guard/source/runtime/custody and final finite records", + "pass": "Complete predeclared wall/aggregate CPU/memory/cost boundary and outside tail displayed; independent reviewer accepts exact scope and gain/no-gain/regression disposition" + } + ], + "measurement_protocol": { + "caps": "Each separately admitted command<=180sec and sampled group<=1073741824bytes; aggregate canonical guarded charge<=2400sec existing allowance. Refresh live ledger, no new budget. Resource failure stops affected route and preserves evidence; it is not a universal impossibility proof.", + "closing_tail": "Predeclare a finite nonrecursive protocol: all substantive worker, validator, cleanup and readback work lies inside the observed group; an outer observer writes one bounded final measurement record after reaping it, then one parent readback. Expose actual observer final-write/readback/publication costs separately as known or unknown OPEN_NOT_ZERO; no claim of all historical/whole-goal physical closure. Reviewer must accept this exact boundary before execution; cannot silently omit parent validation from the measured core.", + "cpu": "Aggregate actual parent/children CPU, including interpreter startup, observer and independent validator; account each process once. Separate wall span from CPU and policy guard charge.", + "end": "Include complete decoding/restoration/preflight/encoding/staging/copy/readback plus parent independent validation, success/failure cleanup and all declared guard/source/runtime/log/custody readbacks before closing the operation record.", + "lifetime": "Controls then baseline then candidate then independent validation, serially, with each arm process exited/reaped before next; parent/observer remain live and counted. Never add unrelated individual maxRSS peaks as though concurrent. Candidate receives no mutable input/receipt state from baseline.", + "memory": "Sample simultaneous RSS of entire admitted parent/descendant group; record interval/PID tracking/missed-short-peak limitations, individual kernel maxRSS separately, and cgroup peak if available with its RSS/cache accounting definition. Guard1GiB is sampled cap; do not label sampled observations exact true peak.", + "selection": "Fixed first observations, no automatic retry/adaptive workload/resizing/winning sample. No unmeasured actual probe in this round.", + "start": "Outer operation clock/resource observation starts before source/runtime checks, input copies, imports, controls and loader allocation. Per-arm inner writer markers supplement inclusive measurement." + }, + "new_control_count": "20 prospective families from accepted prior design, not20 implemented/passed tests; freeze actual names/order/fixtures/count after source exists", + "new_control_families_prospective": [ + "valid source-schema exact finite corpus including legitimate bool/float result slots and fresh ownership", + "transport hash mismatch", + "transport size mismatch", + "invalid/truncated gzip", + "logical size overrun", + "logical digest/final-size mismatch before JSON parse", + "duplicate JSON keys", + "nonfinite constants", + "wrong witness/code key sets or leaf types", + "args arity/exact scalar type", + "label tagged key/arity", + "basis order retention", + "gate/source/output order retention", + "arbitrary-width ints and unchanged decimal errors", + "duplicate ordered rank events", + "bool rejected at int-only rank/result integer fields", + "wrong full rank count", + "wrong distinct-row count", + "before/after mode/byte drift and no cached PASS", + "candidate literal fallback detected without bounded-path credit" + ], + "prerequisites": [ + "Parent independent acceptance of exact frozen loader/consumer/new controls and unchanged reference/candidate code", + "Authentic immutable copies of all3 exact transports plus manifest/anchor, with current before/after mode/hash/identity contract", + "Entire actual source/import/callable/binary/shared-library closure including gzip built-in zlib provider/linked libz, guard and observer", + "Reviewed sampler/observer self-controls: known bounded child allocation, concurrent parent+child allocation, short-lived child and cleanup/timeout/PID-membership behavior; explicit sampling limits", + "Current canonical parent guard ledger and1GiB/180s admission under existing2400s total, including all failures and observer controls", + "Finite final receipt/readback boundary accepted before execution; no automatic continuation if caps fail" + ], + "qualification_matrix": { + "conditional_now": "Required new source, closure, actual controls and all dynamic evidence absent; current packet justifies source preparation only.", + "independent_of_paused_work": "No required O03 dependency identified on paused cache/retention, new scientific construction, full caller O08 or global O09/O10 closure. Those separate obligations stay open.", + "no_demonstrated_total_process_gain": "If common loader peak masks writer savings, disclose actual inclusive and phase results with bounded behavior; no invented percentage threshold. Independent reviewer may accept bounded serialization evidence with NO_DEMONSTRATED_TOTAL_PROCESS_GAIN or regression disposition; never claim measured caller saving.", + "no_go_for_fixed_implementation": "Any immutable-schema mismatch, genuine unsupported row/depth/type causing fallback, exact-byte/receipt/control failure, source/custody drift or cap violation blocks this fixed operation; repair needs a separately reviewed new source and admission. No such actual counterexample obtained here.", + "qualifying_exact_bounded_evidence": "P0-P5 pass, complete genuine fast path, original digests/types/order/control/error contract and measured inclusive/phase memory-cost evidence independently accepted: eligible O03 decision only, no automatic goal credit." + }, + "schema": "o03-smallest-finite-qualifying-operation-spec-v1", + "status": "PROSPECTIVE_UNIMPLEMENTED_UNEXECUTED_NOT_ADMISSION", + "symbolic_bill": { + "artifact_disk": { + "baseline_finals_plus_candidate_stage_and_finals": 182455263, + "both_finals": 121636842, + "candidate_stage_plus_finals": 121636842, + "extras": "immutable input copies, receipts, logs, controls, validator evidence, all failures and metadata are additional; physical device traffic unknown" + }, + "baseline_writer": { + "canonical_encoded_bytes": 60818421, + "final_write_bytes": 60818421, + "writer_hash_bytes": 60818421 + }, + "candidate_writer": { + "additional_work": "factory/freshness/preflight + repeated conservative row bounds + slices/JSON batches/views/punctuation + per-file identities/fstat/flush/close + expected comparison +3 freshness checks +unlink/rmdir success or retained bounded failure manifest", + "copy_hash_bytes": 60818421, + "copy_read_bytes": 60818421, + "final_write_bytes": 60818421, + "private_stage_hash_bytes": 60818421, + "private_stage_write_bytes": 60818421, + "total_hash_bytes": 121636842, + "total_write_bytes": 121636842 + }, + "entire_operation": "All common setup twice + baseline + candidate +C+V+F; report guard policy charges separately from complete measured wall/CPU/peak. No source hashing/import/validation/cleanup is free.94.210533479 at setup is historical policy usage, not full physical total.", + "parent_validation_minimum": "Read both final arms121636842 bytes per full comparison pass; reread freshly authenticated frozen gzip transports17017292 bytes and logical60817894 bytes, plus certificate transport5662 bytes and independent527-byte result canonical projection. Hashing, comparison buffers, parsing of result metadata, manifests/receipts, all source/runtime/guard/log checks and close/readbacks are additional paid work. Exact implementation may add reads; freeze actual call graph before admission.", + "per_arm_common": "startup/import/actual dependency and input custody + staging + T transport hash bytes + G separate gzip transport reread +60817894 logical gzip hash bytes +5662 certificate logical authentication + strict parse/tuple restoration/schema/allocation/releases +mkdir + rank count/distinct set + local streaming S-byte artifact readback/hash + receipt/stdout/close/exit", + "symbols": { + "A": "manifest/anchor/stage/source/runtime/staging bytes", + "C": "all old/new/observer control work", + "F": "failures/cleanup/receipts/outside publication tail", + "G": 17017292, + "L": 60823556, + "S": 60818421, + "T": 17022954, + "V": "parent independent validation and guard/log/custody readbacks" + }, + "unknown_not_zero": [ + "all time/CPU/peak costs", + "source/runtime/import/staging/guard/control bytes and work", + "largest genuine record estimate/depth/batch count", + "JSON/restoration simultaneous liveness", + "physical I/O/cache/syscalls", + "all retained failures", + "finite observer final publication/readback overhead", + "historic physical gaps" + ] + } +} diff --git a/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/SOURCE-PINS-v1.json b/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/SOURCE-PINS-v1.json new file mode 100644 index 0000000000..d3a9c3844b --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/feasibility/technical/SOURCE-PINS-v1.json @@ -0,0 +1,267 @@ +{ + "actual_target_runtime_admitted": false, + "claim": "Pinned source/transport and partial metadata-runtime identities only; not execution custody or complete import closure", + "files": { + "/usr/bin/python3.12": { + "bytes": 8020928, + "mode_octal": "0o755", + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f" + }, + "/usr/lib/python3.12/_compression.py": { + "bytes": 5681, + "mode_octal": "0o644", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981" + }, + "/usr/lib/python3.12/gzip.py": { + "bytes": 24859, + "mode_octal": "0o644", + "sha256": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5" + }, + "/usr/lib/python3.12/hashlib.py": { + "bytes": 9349, + "mode_octal": "0o644", + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab" + }, + "/usr/lib/python3.12/json/__init__.py": { + "bytes": 14020, + "mode_octal": "0o644", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5" + }, + "/usr/lib/python3.12/json/decoder.py": { + "bytes": 12473, + "mode_octal": "0o644", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b" + }, + "/usr/lib/python3.12/json/encoder.py": { + "bytes": 16070, + "mode_octal": "0o644", + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869" + }, + "/usr/lib/python3.12/json/scanner.py": { + "bytes": 2425, + "mode_octal": "0o644", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08" + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "bytes": 64368, + "mode_octal": "0o644", + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe" + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "bytes": 48952, + "mode_octal": "0o644", + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3" + }, + "/usr/lib/python3.12/struct.py": { + "bytes": 257, + "mode_octal": "0o644", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856" + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "bytes": 5309400, + "mode_octal": "0o644", + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a" + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "bytes": 113000, + "mode_octal": "0o644", + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242" + }, + "AGENTS.md": { + "bytes": 387, + "mode_octal": "0o444", + "sha256": "55a69a8d4bd1779075f3b5a19c6ea8d5011ab060b1fb9bb7ba4ea59ab7bfc2b6" + }, + "outputs/h25-data-handling-20261028/control/PLAN-before-granular-progress-v1.md": { + "bytes": 14285, + "mode_octal": "0o444", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e" + }, + "outputs/h25-data-handling-20261028/control/hourly-progress/RUBRIC-v1.json": { + "bytes": 6249, + "mode_octal": "0o444", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/STAGE.json": { + "bytes": 26241, + "mode_octal": "0o664", + "sha256": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json": { + "bytes": 1926, + "mode_octal": "0o664", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/check_artifacts.py": { + "bytes": 4735, + "mode_octal": "0o664", + "sha256": "115d36662856ded048d3a57210b4cbe4a8091375e79d5fcac2856d5d0cfe234f" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py": { + "bytes": 10571, + "mode_octal": "0o664", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py": { + "bytes": 8959, + "mode_octal": "0o664", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_circuit.py": { + "bytes": 19732, + "mode_octal": "0o664", + "sha256": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/source/complex_network.py": { + "bytes": 6105, + "mode_octal": "0o664", + "sha256": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json": { + "bytes": 1912, + "mode_octal": "0o664", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json": { + "bytes": 5662, + "mode_octal": "0o664", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "mode_octal": "0o664", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "mode_octal": "0o664", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/integration/full_driver.py": { + "bytes": 22480, + "mode_octal": "0o664", + "sha256": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1" + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/review/SERIALIZER-FEASIBILITY-REVIEW-v1.json": { + "bytes": 17268, + "mode_octal": "0o664", + "sha256": "7627f233cc6c1e1f34e08bc1529056529d6a95a47e10b32bbf6e8c9de4554b7b" + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/FEASIBILITY-v1.json": { + "bytes": 7382, + "mode_octal": "0o444", + "sha256": "f32e039aaf8e9ebe7a6f75580fc93c443c30ee9b4a2d836a56b2132eeea22fde" + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/INPUT-BILL-v1.json": { + "bytes": 8994, + "mode_octal": "0o444", + "sha256": "a41c28cf1ae2a2517c38589625c55f9df9a6634fa4f0a288882afe7597d67fac" + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/NEXT-SOURCE-v1.md": { + "bytes": 11252, + "mode_octal": "0o444", + "sha256": "f4d3ae05e4e36f2b55894202a79968666b6ce5255daca45c6283387713f903c9" + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/PACKAGE-PINS-v1.json": { + "bytes": 901, + "mode_octal": "0o444", + "sha256": "b1876eaba73b38b3a20a1fab9e412b85f7f0b7935af03c0f0d6637b02b0d78a4" + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/serializer-feasibility/SOURCE-PINS-v1.json": { + "bytes": 7910, + "mode_octal": "0o444", + "sha256": "372be0d3f2ad4cea77832f83c8dec17787828c0e923ebbeae28075aeebee54fe" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/BILL.json": { + "bytes": 5749, + "mode_octal": "0o444", + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/CONTROL-SPEC.json": { + "bytes": 3062, + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/FEASIBILITY.json": { + "bytes": 3071, + "mode_octal": "0o444", + "sha256": "f9ff50549bae4071fb7531fe6ad2e53d2b593b8508d42dce6194ea7c3e012a61" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/SOURCE-PINS.json": { + "bytes": 3914, + "mode_octal": "0o444", + "sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/component_consumer.py": { + "bytes": 6761, + "mode_octal": "0o444", + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/docs/API-v2.md": { + "bytes": 6025, + "mode_octal": "0o444", + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/docs/API-v3.md": { + "bytes": 2421, + "mode_octal": "0o444", + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/docs/CONTRACT-v2.json": { + "bytes": 2962, + "mode_octal": "0o444", + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/docs/SOURCE-READINESS-v3.json": { + "bytes": 773, + "mode_octal": "0o444", + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/provenance/compare_side_verifier.py": { + "bytes": 10571, + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/provenance/profile_side_verifier.py": { + "bytes": 8959, + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/reference.py": { + "bytes": 2141, + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/PLAN-v1.md": { + "bytes": 3671, + "mode_octal": "0o444", + "sha256": "ab2d7add19cf87e52d168e1536b722115ff5e23d9916155231bc45c64c2eaaf4" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-feasibility-20261031/control/AUTHORIZATION-v1.json": { + "bytes": 587, + "mode_octal": "0o444", + "sha256": "45a9d1a345a30a2783b1e5797086869eb91e260d29ce5350aa896bce900a8948" + } + }, + "schema": "o03-technical-source-pins-v1" +} diff --git a/research/h25-authentic-serializer-20261031/provenance/implementation/PLAN-v1.md b/research/h25-authentic-serializer-20261031/provenance/implementation/PLAN-v1.md new file mode 100644 index 0000000000..e24ed3595c --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/implementation/PLAN-v1.md @@ -0,0 +1,38 @@ +# O03 authentic serializer implementation round + +Direct user authorization starts a new GPT-6.1-sol high implementation and delivery round following independently accepted serializer-o03-feasibility-20261031/review/REVIEW-v1.json. Preserve unchanged O03/Area3 scope and every Q1-Q5 prerequisite and P0-P5 operation. The complete original goal and denominators are unchanged; no fresh scientific construction, cache, retention or mathematics are resumed. + +## Ownership and work + +Parallel source workers own loader/, consumer/ and envelope/ exclusively. Loader owns strict authentic transport/JSON/schema restoration and its concrete controls; consumer owns full baseline/candidate consumer, separate independent validator and its concrete controls; envelope owns immutable custody/runtime closure, inclusive guard/observer/source controls and exact parent command/admission proposal. Independent reviewer owns review/ and can accept frozen lanes separately only within their complete explicit scope; combined execution admission still requires every dependency. Parent owns control/, reports/, staging/admission/serialized guarded execution and publication. No worker may execute/import target code, decompress payloads, run controls/benchmarks, inspect target processes or publish. Bounded source, AST and metadata hash operations are permitted. Coordinate interfaces promptly; preserve each other's files. + +## Fixed local checkpoints + +I1: independently accepted authentic loader plus concrete ordered loader controls. +I2: independently accepted complete consumer, independent validator and consumer controls, preserving exact original reference/candidate/EXPECTED and 70 original controls per mode. +I3: independently accepted actual custody/runtime/observer/guard/measurement source and concrete observer controls plus complete operation bill. +I4: parent-approved exact immutable stage and fixed operation admission under existing guarded budget and limits. +I5: executed and independently accepted normal/optimized old and new controls plus observer controls. +I6: fixed first full baseline/candidate pair with independently validated complete outputs/receipts/fast path/custody/cleanup. +I7: independently accepted inclusive memory/cost/gain-or-no-gain evidence and explicit unchanged-O03 qualification decision. +I8: incremental scoped draft PR commits, exact-head recorded hosted checks and Chrome handoff readback. + +These 8 local checkpoints are reporting granularity, not substitutes for original 49 activities, 10 stage gates, 10 overall milestones or 24 component checkpoints. Inherited feasibility acceptance grants no new milestone credit or timer reset. Authored/pending/design work grants no acceptance. + +## Timeboxes and cadence + +One fresh hard 60-minute implementation/review/delivery timebox starts at AUTHORIZATION-v1.json. Target initial author packets within 15 minutes, first independent complete-lane review by 25 minutes, combined source review by 35 minutes, then admitted controls/replay and delivery if feasible. At most one 15-minute source repair is permitted within the fixed 60-minute round, never an automatic extension. Thirty continuous minutes without a new independently accepted local checkpoint pauses this round and freezes evidence. Each genuine new higher accepted checkpoint count resets only this round's no-progress clock. The previous cache and closed stream timers are not reused. Stop sooner for decisive NO-GO, failed cap/control/receipt or complete delivery. Preserve failures and current source hashes. + +The existing 15-minute reporting schedule must follow this stream first while retaining older source counts and hourly original-goal qualification. State authored, independently source-accepted, executed, complete-caller and measured evidence separately; report unchanged/paused states as the user requested. + +## Execution and evidence + +Parent alone may execute after independent complete-source admission. Reuse current ledger: 94.210533479/2400 policy seconds at setup is historical until refreshed. No new budget; each command <=180 seconds, sampled process group <=1 GiB; serialized guarded queue; all failures/control/validation/observer costs charged. Fixed first full baseline and candidate only, no retry/reroll/adaptive resizing, and no smaller/synthetic substitute for genuine data. Revalidate complete actual dependency closure, exact types/order, original EXPECTED, complete fast-path marker, all failure semantics, cleanup and fresh immutable custody. Preserve all technical/PROBE-SPEC-v1.json Q/P conditions. No protected outputs/h25-bookkeeping-swarm-20261028/runtime/runs access. + +Accept finite inclusive measurement before dispatch: source/runtime authentication, input staging, imports, controls, decoding/restoration, serialization, copies, independent validation, cleanup and declared readbacks are included. Distinguish sampled simultaneous group RSS from individual maxRSS; expose final observer-write/parent-readback/publication tail as OPEN_NOT_ZERO. No retroactive closure of prior F7, historical timing gaps, O08 full caller or O09 whole-goal costs. Gain is reported honestly with no minimum numerical target. + +## Incremental publication + +Prepare an isolated, portable export and independent review before publication. Commit 1: self-contained independently source-accepted loader/consumer/controls and explicit unexecuted limitations. Commit 2: immutable executed evidence, independent qualification or retained failure disposition. Keep scope truthful; no empty or unreviewed commits to simulate progress. Use established Clear1nsight fork/upstream CrocSwap workflow and Chrome PR/handoff readback, attach created PR, retain exact head/check states and separate hosted planning from replay. Never merge automatically. If source readiness fails, preserve checkpoint and do not publish unsafe/incomplete executable packages. + +The live app goal service is separately observed paused; current direct user authority resumes only this named stream. Update goal documentation/canonical state honestly without claiming an unavailable API changed goal-service status. diff --git a/research/h25-authentic-serializer-20261031/provenance/implementation/control/AUTHORIZATION-v1.json b/research/h25-authentic-serializer-20261031/provenance/implementation/control/AUTHORIZATION-v1.json new file mode 100644 index 0000000000..f90b3903b7 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/implementation/control/AUTHORIZATION-v1.json @@ -0,0 +1,23 @@ +{ + "cache_retention_math_resumed": false, + "created_utc": "2026-10-31T08:04:36.048558+00:00", + "existing_guarded_cap_seconds": 2400, + "goal_service_status_observed": "paused", + "hard_deadline_utc": "2026-10-31T09:04:36.048558+00:00", + "historical_and_final_metadata_publication_costs": "OPEN_NOT_ZERO", + "initial_no_progress_deadline_utc": "2026-10-31T08:34:36.048558+00:00", + "maximum_command_seconds": 180, + "model": "gpt-6.1-sol", + "new_budget_granted": false, + "plan": { + "path": "streams/serializer-o03-implementation-20261031/PLAN-v1.md", + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234" + }, + "reasoning_effort": "high", + "repair_limit": 1, + "repair_minutes_within_hard_deadline": 15, + "sampled_group_cap_bytes": 1073741824, + "schema": "serializer-o03-implementation-authorization-v1", + "scope": "Authentic complete retained-value O03 serializer loader/consumer/controls; reviewed custody/execution/measurement; incremental scoped PR delivery", + "user_request": "Use 6.1-sol high agents to start this suggested stream of work. Update goal. Add time boxing and progress updates. Add incremental PR commits." +} diff --git a/research/h25-authentic-serializer-20261031/provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json b/research/h25-authentic-serializer-20261031/provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json new file mode 100644 index 0000000000..6b6e19c688 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json @@ -0,0 +1,61 @@ +{ + "all_three_match_in_both_repositories": true, + "method": "Connected GitHub read-only contents metadata at exact known commit in upstream and fork; matches independently computed local Git blob IDs and sizes. No payload download/decode or runtime custody claim.", + "observed": { + "fork_transports": [ + { + "name": "complex-network.json", + "path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "type": "file", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/contents/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json?ref=e05aad954689d0ee21baff19b4674f1fcb2e838f" + }, + { + "name": "rank-trace.json.gz", + "path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "sha": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "size": 22029, + "type": "file", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/contents/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz?ref=e05aad954689d0ee21baff19b4674f1fcb2e838f" + }, + { + "name": "witness.json.gz", + "path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "sha": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "size": 16995263, + "type": "file", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/contents/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz?ref=e05aad954689d0ee21baff19b4674f1fcb2e838f" + } + ], + "upstream_transports": [ + { + "name": "complex-network.json", + "path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "type": "file", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json?ref=e05aad954689d0ee21baff19b4674f1fcb2e838f" + }, + { + "name": "rank-trace.json.gz", + "path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "sha": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "size": 22029, + "type": "file", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz?ref=e05aad954689d0ee21baff19b4674f1fcb2e838f" + }, + { + "name": "witness.json.gz", + "path": "research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "sha": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "size": 16995263, + "type": "file", + "url": "https://api.github.com/repos/CrocSwap/integer-mult-bounds/contents/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz?ref=e05aad954689d0ee21baff19b4674f1fcb2e838f" + } + ] + }, + "observed_utc": "2026-10-31T08:12:12.122271+00:00", + "schema": "o03-remote-input-object-verification-v1", + "source_commit": "e05aad954689d0ee21baff19b4674f1fcb2e838f" +} diff --git a/research/h25-authentic-serializer-20261031/provenance/original-goal/control/PLAN-before-granular-progress-v1.md b/research/h25-authentic-serializer-20261031/provenance/original-goal/control/PLAN-before-granular-progress-v1.md new file mode 100644 index 0000000000..97b016c958 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-goal/control/PLAN-before-granular-progress-v1.md @@ -0,0 +1,91 @@ +# Verification data-handling plan + +Address the six audited areas, starting with the inner runner's unbounded log reads. Use parallel GPT-6.1-sol agents at high for source investigation, implementation and independent review, with one parent-owned queue for compiler work, scientific execution, resource tests and measurements. The user explicitly authorized this plan, swarm and completion goal on 2026-10-28. + +## Baseline and preservation + +The comparison baseline is PR6029 publication `e05aad954689d0ee21baff19b4674f1fcb2e838f`, package `research/h25-bookkeeping`, in its complete combined native configuration. Local immutable stage v4 is `outputs/h25-bookkeeping-swarm-20261028/stages/v4`, SHA-256 `558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc`. The previous performance goal is complete; its times, source and hosted CI are historical evidence, not new measurements or current upstream status. + +Preserve every existing source, raw run, failure, receipt, archive and original thread. Synced `sources/` remains read-only. Author new candidates in this round; do not patch the prior publication checkout or immutable stages. Authenticate a separate reference closure before any run. Keep original and candidate computations in distinct instances/processes; never share mutable answers or saved validation PASS results between independent paths. Mathematical streams, unrelated feeds and automations remain paused. + +Retain exact certificate/stdout/types, ordered witnesses/rank/complement bytes and prefixes, call coverage, fallback/error behaviour, source/ownership checks and runtime freshness. Failure artifacts remain visible. Published source snapshots stay immutable; any repaired implementation receives a new stage/version and keeps failed evidence. + +## Parallel lanes and ownership + +| Area | Agent | Owned directory | Initial deliverable | +|---|---|---|---| +| 1 Log handling | `data_log_guard` | `areas/log-handling/` | Minimal bounded-read fix and real file/process controls; first execution priority | +| 2 Construction memory | `data_construction` | `areas/construction/` | Reuse exact support unions; prove construction-index lifetime before retirement | +| 3 Witness serialization | `data_serialization` | `areas/serialization/` | Bounded serializer preserving exact bytes and final-file failure semantics | +| 4 Evidence retention | `data_retention` | `areas/retention/` | Immutable content-addressed archive, manifests and exact restoration; no existing-file deletion | +| 5 Cache validity | `data_cache_contract` | `areas/cache-validity/` | Mutation-safe cache contract and independent negative controls | +| 6 Hashing and rank observations | `data_digest_trace` | `areas/hashing-traces/` | Same-call digest reuse and bounded/reused immutable observation metadata | +| Independent review | `data_review` | `review/` | Source/contract gates, interference review and final evidence audit | +| Parent | Main agent | `control/`, `integration/`, `stages/`, `runtime/`, `validation/`, `publication/` | Shared interfaces, all execution, integration and delivery | + +All agents use the explicit project workspace for filesystem commands. They are not alone in the workspace, may not revert others and may edit only their owned directories. Workers do not import/execute scientific modules, compile, decode large scientific corpora, run timings or publish. They may inspect source, read bounded existing receipts, AST-parse source and prepare controls. Research and disjoint implementation run concurrently after their gates; shared original-module transformations belong to the parent. + +Reuse one parent inventory, run index and upstream refresh. Batch independent bounded reads. Reuse source-review results only while exact source digests and dependencies match. Refresh external state at the publication boundary; avoid repeated unchanged polling. This does not remove any live scientific check or declared cold cost. + +## Area-specific work and completion gates + +### 1. Fix bounded log handling first + +The inner runner currently reads complete stdout/stderr into memory before its final output-cap check. Author a new runner revision that checks file sizes before materialization, stream-hashes complete retained evidence with bounded memory, emits only bounded previews and checks final sizes/counts after streaming. Preserve exact byte hashes/counts, STOP reasons, stderr rejection, all failed outputs, unique evidence directories, process cleanup and resource limits. The existing outer publication guard is a useful source precedent, not a reason to skip inner-runner repair. + +Before other numerical work, independently review and run normal output, binary output, stderr failure, nonzero exit and bounded oversized/fast-exit controls. Verify STOP on oversize and bounded parent memory, including the post-exit path. Keep all adversarial fixtures small and predeclared. Integrate the fixed runner into this round's actual execution path; a library with no consumer is insufficient. + +### 2. Reduce construction memory and duplicate unions + +Compute each exact `sa | sb` union once and reuse that immutable value for the `(kind, mask)` lookup key and support storage. Preserve node identity/order, lookup semantics and every arithmetic assertion. Separately establish when construction is permanently finished. Retire or release the deduplication index only within a proven frozen-caller phase; preserve behaviour for APIs that can resume construction. Do not delete lookup state merely because it looks unused in one receipt. + +Compare complete graph/witness bytes against the unchanged reference and test duplicate additions, kind distinctions, invalid/callback-bearing domains and the phase boundary. Measure memory after construction and the full-process peak; do not infer savings from object counts alone. + +### 3. Bound witness serialization memory + +The retained witness is 58,143,622 bytes; current encoding materializes large complete JSON buffers. Design bounded output using the exact existing sorted-key ASCII schema, integer representation and ordered collections. Investigate C-backed/chunked approaches before accepting a large Python serialization slowdown. The 7,311-byte typed return is not the dominant target. + +Compute digests while producing exact bytes. Stage private temporary files and expose final artifact names only after all required serialization and expected-digest checks pass, preserving original rejection/write semantics. Keep the unchanged reference encoder separate. Cover Unicode/escaping, arbitrary-width integers, types, ordering, boundaries, malformed values, conversion exceptions and partial-write cleanup. Validate complete original artifact digests and measured peak RSS. Charge buffers, conversion, hashing, writes, controls and cleanup. + +### 4. Reduce archival duplication without losing evidence + +The audit freshly verified 12 distinct witness files with identical content, totaling 697,723,464 logical bytes. Create a new reversible archive containing immutable content blobs plus per-run manifests, modes, provenance and every individual receipt/failure. Verify blobs before reuse and verify exact restoration into a new external directory. Avoid writable hardlink aliases across runs. Reject path traversal, symlinks, missing/mutated blobs, wrong modes and incomplete manifests; bound memory and declared restored sizes. + +Existing raw runs and archives remain untouched. Deduplication is post-run retention and must not remove the writes or controls paid by scientific measurements. Demonstrate a smaller derived archive and exact reconstruction, with archival cost reported separately. Integrate the new retention path for new completed runs after its correctness gate. + +### 5. Make cache reuse valid under its declared data contract + +`Label.key` is captured once while `basis` remains mutable, and verdict caches use that key. The frozen caller keeps bases stable; extending reuse to mutable requests requires explicit validation or invalidation. Design a source-bound cache boundary that cannot return a stale PASS after basis/key/dimension or relevant calling-environment drift. Keep supported mutable-API behaviour through validated snapshots/versioning or literal uncached fallback; reject unsupported drift before reuse. Do not substitute a shared oracle for an independent check. + +Use independent uncached reference computations for mutation-between-request, alias, key collision, type, source/native binding and callback controls. Prove the original frozen caller is unchanged. Record the full cost of every added check and any retained cache state. + +### 6. Remove duplicate digest work and improve rank observation retention + +Reuse a digest of the same already-read bytes within one inventory/authentication invocation and compare it against every independent expected manifest. Retain distinct before/after trust boundaries and all required source checks. Never cache a source or runtime PASS across changes. + +Rank observations retain 59,959 records covering 252 distinct matrices. Investigate interning exact immutable observational rows or a bounded exact recorder. Recompute all original arithmetic and retain every ordered event, result and final canonical byte; this is not rank-answer memoization or duplicate-call removal. Unsupported/callback-bearing values retain literal behaviour. Preserve collector interface and runtime closure identity; include admission, lookup, encoding and cleanup costs. + +## Execution sequence + +1. **G0: establish closure and interfaces.** Authenticate the baseline, freeze ownership/cost/error contracts and create the new ledger. Source research for all six areas begins in parallel. The independent reviewer prioritizes Area1 immediately. +2. **G1: deliver the log fix.** Review its minimal source patch, run bounded adversarial controls in the parent queue and prove the actual new runner uses it. No full verifier run precedes this gate. +3. **G2: parallel source construction, serial finite gates.** Each area supplies `PROPOSAL.json`, interface notes, source hashes and complete positive/negative control bill. Parent admits and executes candidates one at a time. Changes to common files are integrated only by the parent. +4. **G3: attribute memory and integrate.** Use one bounded full diagnostic if needed to distinguish construction, graph retention, witness materialization and encoding peaks. Finalize all helper/class/native bindings before guard capture; respect the existing private-set adapter's original-source authentication and final lease sealing. Never patch captured wrappers afterward. Freeze a source-reviewed combined stage and execute the complete old/new control union in normal/O modes, with the full caller assertion-on. +5. **G4: complete validation and measurement.** Reproduce exact full outputs, observe wall/CPU/peak RSS, measure archive size and restoration, and account for all new costs. Freeze a same-session comparison protocol before measuring; retain all samples and failures. New source gets new measurements; earlier PR6029 timings do not qualify a new factor. Assess regressions and revise mechanisms when required. This task has no newly invented percentage promise. +6. **G5: delivery.** Package reproducible source, controls, raw evidence, all six final dispositions and a compact checkpoint. Verify read-only/Git-free execution, external output paths, committed source/modes/raw ancestry and lossless export. Refresh applicable upstream guidance/overlap, use the established nonforce fork/Chrome PR workflow, and verify the published commit's hosted checks and required handoff readbacks. Preserve predecessor/license/AI credit and keep correctness separate from performance. + +## Shared interfaces and conflict prevention + +Workers return source-bound factories/helpers and do not edit the frozen `complex_circuit.py`, backend or full driver. Constructor, cache and rank changes interact with original-source admission and captured closures. The parent first authenticates original functions, installs reviewed variants in the declared order, finalizes trace/native wrappers and captures guard state, then seals the private caller lease around the actual CLI. The reviewer must approve the concrete ordering rather than assume each independent patch composes safely. + +The serializer owns byte production; the rank lane owns observation representation; the retention lane owns post-run archive layout. They agree explicit interfaces before coding overlapping assumptions. Archive references never replace fresh computation, scientific outputs or independent comparison inputs. + +## Resources and stopping rules + +One parent lock/queue covers compilers, adverse process controls, scientific imports, finite/full runs and measurements. Initial feasibility allowance: 600 seconds of guarded commands; total new-round allowance: 2,400 seconds, including failures, controls, compilation, diagnostic and delivery replays. Cap each scientific command at180seconds and sampled memory at1GiB; ordinary output cap remains2MiB. Any intentionally larger output fixture has a separately declared bounded size and an expected STOP. No automatic retry or timing reroll. These are new authorized task limits; the previous ledgers remain unchanged. + +Resource/source/output failures stop the affected run, retain evidence and require a reviewed new source version for repair. An implementation difficulty does not complete an area. If a proposed mechanism cannot preserve the contract, independently document the obstruction and pursue another safe mechanism; unresolved requirements remain explicit and the goal incomplete. + +## Completion criteria + +Complete only after the actual log-handling path is fixed and tested; construction and serialization improvements are implemented and validated; reversible archival reuse preserves every run's evidence; cache reuse has tested invalidation/fallback; digest/rank handling retains all checks and ordered observations; the combined complete caller and resource measurements pass; and delivery/required publication readbacks are finished. Keep source-derived expectations, measured improvements, hypotheses and unresolved risks distinct. No unrelated research, monitoring or automation is included. diff --git a/research/h25-authentic-serializer-20261031/provenance/original-goal/control/hourly-progress/RUBRIC-v1.json b/research/h25-authentic-serializer-20261031/provenance/original-goal/control/hourly-progress/RUBRIC-v1.json new file mode 100644 index 0000000000..5d78a24205 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-goal/control/hourly-progress/RUBRIC-v1.json @@ -0,0 +1,160 @@ +{ + "baseline_overall_percent": 10, + "baseline_stage_percent": 20, + "complete_only_if_all_original_goal_requirements_true": true, + "created_utc": "2026-10-29T20:17:08.097394+00:00", + "method": "Conservative acceptance-gate completion: equal weight within each fixed checklist; percentage=100*fully evidenced achieved gates/total gates. Partial, source-only, conditional, unexecuted, unknown and unverified work earns no fractional gate credit. Counts describe acceptance gates, not effort, elapsed time, ETA or universal correctness.", + "overall_denominator": 10, + "overall_gates": [ + { + "achieved": true, + "criterion": "Bounded retained-log handling implemented, installed and independently validated", + "evidence": [ + { + "path": "review/log-handling-v1-execution/REVIEW.json", + "scope": "Independently accepted installed bounded-log runner and real file/process controls", + "sha256": "bce18e269d06e2f2ca0e518996e5ea8186bdba2b610375b82030df175ef8a7fa" + } + ], + "id": "O01" + }, + { + "achieved": false, + "criterion": "Construction union/index-lifetime improvement validated on the complete caller with memory/cost evidence", + "evidence": [], + "id": "O02" + }, + { + "achieved": false, + "criterion": "Bounded exact witness serialization validated on complete artifacts with memory/cost evidence", + "evidence": [], + "id": "O03" + }, + { + "achieved": false, + "criterion": "Exact reversible archive and automatic completed-run retention implemented and validated", + "evidence": [], + "id": "O04" + }, + { + "achieved": false, + "criterion": "Current mutation-safe cache validity/fallback implemented and completely validated", + "evidence": [], + "id": "O05" + }, + { + "achieved": false, + "criterion": "Same-call digest and immutable ordered rank-observation reuse validated on complete outputs and costs", + "evidence": [], + "id": "O06" + }, + { + "achieved": false, + "criterion": "Current integrated source/ownership/runtime prerequisites and complete old/new control union passed", + "evidence": [], + "id": "O07" + }, + { + "achieved": false, + "criterion": "Complete assertion-on baseline/candidate caller reproduces every required exact output and check", + "evidence": [], + "id": "O08" + }, + { + "achieved": false, + "criterion": "Complete wall/CPU/peak-memory/archive costs and reproducible gain or final measured dispositions established", + "evidence": [], + "id": "O09" + }, + { + "achieved": false, + "criterion": "Reproducible Git-free export and scoped upstream publication, exact-head hosted checks and readbacks complete", + "evidence": [], + "id": "O10" + } + ], + "schema": "h25-hourly-progress-acceptance-gate-rubric-v1", + "stage_denominator": 10, + "stage_gates": [ + { + "achieved": true, + "criterion": "Baseline source pin, preservation boundary and guarded resource/accounting contract established", + "evidence": [ + { + "path": "stages/predecessor-pr6029-v1/STAGE.json", + "scope": "Pinned original PR6029 source-stage manifest; no current runtime/CI inference", + "sha256": "9e63ce3e9799e150fa144ff01c1684468404363fd4222aef98442a87c2210d12" + }, + { + "path": "control/EXECUTION-PHASE.json", + "scope": "Guarded serial queue, new-round caps and cost/preservation contract", + "sha256": "77fc9f89a2b3c572a3bfe52b35ba234532ab9298dd3a08c8b75c17a7a6661db4" + } + ], + "id": "S01" + }, + { + "achieved": true, + "criterion": "Bounded log runner integrated and independently validated with real file/process controls", + "evidence": [ + { + "path": "review/log-handling-v1-execution/REVIEW.json", + "scope": "Independently accepted installed bounded-log runner and real file/process controls", + "sha256": "bce18e269d06e2f2ca0e518996e5ea8186bdba2b610375b82030df175ef8a7fa" + } + ], + "id": "S02" + }, + { + "achieved": false, + "criterion": "All six current implementation contracts closed, including cache validity and automatic retention", + "evidence": [], + "id": "S03" + }, + { + "achieved": false, + "criterion": "Complete current model/control payload and resource fit established", + "evidence": [], + "id": "S04" + }, + { + "achieved": false, + "criterion": "Complete original and new control-body union and identity mapping independently accepted", + "evidence": [], + "id": "S05" + }, + { + "achieved": false, + "criterion": "All required current bootstrap, owner, native, FFI and runtime profiles qualified", + "evidence": [], + "id": "S06" + }, + { + "achieved": false, + "criterion": "Complete current combined stage, source bindings and caller assembly independently accepted", + "evidence": [], + "id": "S07" + }, + { + "achieved": false, + "criterion": "Complete old/new normal-mode control union passed on the current combined stage", + "evidence": [], + "id": "S08" + }, + { + "achieved": false, + "criterion": "Complete old/new optimized-mode control union passed on the current combined stage", + "evidence": [], + "id": "S09" + }, + { + "achieved": false, + "criterion": "Full assertion-on comparison caller and fixed measurement/resource protocol admitted", + "evidence": [], + "id": "S10" + } + ], + "stage_id": "G2_G3_INTEGRATION_CONTROL_QUALIFICATION", + "stage_name": "Source integration, fit and complete-control qualification", + "update_policy": "Preserve this denominator and criteria for this stage and overall goal. Append timestamped reports and link exact newly qualifying evidence. Revoke credit if evidence no longer applies. Source case counts and narrower accepted outcomes are reported separately. If the stage completes, adopt a new versioned checklist derived from the next PLAN stage and explicitly report the stage transition; never silently change denominators or move unfulfilled requirements." +} diff --git a/research/h25-authentic-serializer-20261031/provenance/original-serializer/ORIGINAL-SOURCE-PINS.json b/research/h25-authentic-serializer-20261031/provenance/original-serializer/ORIGINAL-SOURCE-PINS.json new file mode 100644 index 0000000000..1767b5809d --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-serializer/ORIGINAL-SOURCE-PINS.json @@ -0,0 +1,69 @@ +{ + "schema": "h25-serializer-original-source-pins-v1", + "sources": { + "outputs/h25-data-handling-20261028/areas/serialization/API-v2.md": { + "bytes": 6025, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "outputs/h25-data-handling-20261028/areas/serialization/API-v3.md": { + "bytes": 2421, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "outputs/h25-data-handling-20261028/areas/serialization/CONTRACT-v2.json": { + "bytes": 2962, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "outputs/h25-data-handling-20261028/areas/serialization/COST-CONTROLS.json": { + "bytes": 11322, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "outputs/h25-data-handling-20261028/areas/serialization/SOURCE-READINESS-v3.json": { + "bytes": 773, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "outputs/h25-data-handling-20261028/areas/serialization/bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "outputs/h25-data-handling-20261028/areas/serialization/serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o664", + "reviewed_bytes_and_hash_match": true, + "reviewed_mode_matches": true, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/compare_side_verifier.py": { + "bytes": 10571, + "mode_octal": "0o664", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/native_backend.py": { + "bytes": 20334, + "mode_octal": "0o664", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/engine/profile_side_verifier.py": { + "bytes": 8959, + "mode_octal": "0o664", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + } + } +} diff --git a/research/h25-authentic-serializer-20261031/provenance/original-serializer/REFERENCE-EXTRACTION.json b/research/h25-authentic-serializer-20261031/provenance/original-serializer/REFERENCE-EXTRACTION.json new file mode 100644 index 0000000000..8a7e774b8e --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-serializer/REFERENCE-EXTRACTION.json @@ -0,0 +1,51 @@ +{ + "extraction_method": "ast.parse and byte line slicing; no target imports or execution", + "extracts": [ + { + "exact_excerpt_bytes": 30, + "exact_excerpt_sha256": "fd7110dda22ef55a34a0f526d6067d6b5060bb81cf970f08053563faff756e81", + "join_policy": "exact source lines; inter-definition blank spacing may differ", + "source": "provenance/native_backend.py", + "source_end_line": 37, + "source_start_line": 37, + "symbol": "_RUNTIME_ERROR" + }, + { + "exact_excerpt_bytes": 93, + "exact_excerpt_sha256": "3dc5458e69ff906eb2ff92f5438f884e3f7e06db443ad06aeb5be9dcd49645cf", + "join_policy": "exact source lines; inter-definition blank spacing may differ", + "source": "provenance/native_backend.py", + "source_end_line": 55, + "source_start_line": 53, + "symbol": "require" + }, + { + "exact_excerpt_bytes": 125, + "exact_excerpt_sha256": "2322855d535eb34a5af6b93e5b7002a90723ed3b432160ffd3985632a3a29928", + "join_policy": "exact source lines; inter-definition blank spacing may differ", + "source": "provenance/profile_side_verifier.py", + "source_end_line": 37, + "source_start_line": 36, + "symbol": "canonical" + }, + { + "exact_excerpt_bytes": 362, + "exact_excerpt_sha256": "1ea012a80098f192b08f719c49b85d2d8a2385dc4f662beb1ea5aade8a99e49b", + "join_policy": "exact source lines; inter-definition blank spacing may differ", + "source": "provenance/compare_side_verifier.py", + "source_end_line": 32, + "source_start_line": 26, + "symbol": "EXPECTED" + }, + { + "exact_excerpt_bytes": 1170, + "exact_excerpt_sha256": "15693e130662f13ae01d572e2658331be866704cc5d5f3bfd61cdd9ee0ffee92", + "join_policy": "exact source lines; inter-definition blank spacing may differ", + "source": "provenance/compare_side_verifier.py", + "source_end_line": 93, + "source_start_line": 74, + "symbol": "write_scientific" + } + ], + "schema": "h25-serializer-reference-extraction-v1" +} diff --git a/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/compare_side_verifier.py b/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/compare_side_verifier.py new file mode 100644 index 0000000000..d94920c274 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/compare_side_verifier.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python3 +"""One cold finite or complete side-verification run, under the parent's guard. + +The baseline and candidate serialize identical complete result, structural/ +label/role witness, and rank transcript artifacts. Candidate additionally pays +all C compilation/link/load and independent finite/binding/fallback controls. +No profile or warm-build reuse; no orchestration, retry, search or parallelism. +""" +from __future__ import annotations + +import time +START_WALL = time.perf_counter() +import argparse +import hashlib +import json +from pathlib import Path +import resource +import sys + +sys.dont_write_bytecode = True +from native_backend import (ROOT, SOURCE_SHA256, CALLER_SHA256, ComplementTrace, attach_trace, + bind, build_native, guard_module, load_source, require) +from finite_controls import run_controls +from profile_side_verifier import canonical, source_check + +EXPECTED = { + "result_sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c", + "exact_witness_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "rank_trace_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "rank_call_count": 59959, + "rank_distinct_matrix_count": 252, +} + + +def cpu_seconds(): + own = resource.getrusage(resource.RUSAGE_SELF) + children = resource.getrusage(resource.RUSAGE_CHILDREN) + return own.ru_utime + own.ru_stime + children.ru_utime + children.ru_stime + + +def scientific_run(module, phases): + def phase(name, action): + wall, cpu = time.perf_counter(), cpu_seconds() + answer = action() + phases[name] = {"wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu} + return answer + + c = phase("construction", lambda: module.ComplexSideCircuit(25)) + checks = phase("checks_initialization", lambda: module.Checks(c)) + code = phase("compile_roles", lambda: module.compile_roles(c)) + side_map = phase("verify_map", checks.verify_map) + labels = phase("verify_labels", checks.verify_labels) + roles = phase("verify_role_frames", lambda: module.verify_role_frames(c, checks, code)) + result = {"circuit": c.stats(), "side_map": side_map, "labels": labels, "role_frames": roles} + # This exactly matches profile_side_verifier.py's predeclared witness + # representation. Preserve basis and code dict insertion order as lists. + witness = { + "support": c.support, + "args": c.args, + "kind": c.kind, + "active": sorted(c.active), + "pieces": [(target, node, (coefficient.numerator, coefficient.denominator)) + for target, node, coefficient in c.pieces], + "labels": [(key, list(label.basis.items()), label.dim, label.key) + for key, label in checks.cache.items()], + "code": {"roles": code["roles"], "gates": code["gates"], + "sources": list(code["sources"].items()), + "outputs": list(code["outputs"].items())}, + } + return result, witness + + +def write_scientific(output, result, witness, rank_calls): + encoded_result = canonical(result) + encoded_witness = canonical(witness) + encoded_trace = canonical(rank_calls) + receipt = { + "result_sha256": hashlib.sha256(encoded_result).hexdigest(), + "exact_witness_sha256": hashlib.sha256(encoded_witness).hexdigest(), + "rank_trace_sha256": hashlib.sha256(encoded_trace).hexdigest(), + "rank_call_count": len(rank_calls), + "rank_distinct_matrix_count": len({rows for rows, _ in rank_calls}), + } + require(receipt == EXPECTED, "Complete output, ordered witness, or rank trace changed from the frozen profile") + # Same exact bytes and serialization work in both arms; file hashes omit + # a trailing newline exactly as the existing profile's digest did. + (output / "result.json").write_bytes(encoded_result) + (output / "witness.json").write_bytes(encoded_witness) + (output / "rank-trace.json").write_bytes(encoded_trace) + receipt["serialized_bytes"] = {"result": len(encoded_result), "witness": len(encoded_witness), + "rank_trace": len(encoded_trace)} + return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--mode", choices=("finite", "baseline", "candidate"), required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--expected-complement-sha256", help="Lock to the parent-recorded fresh v2 baseline complement stream") + args = parser.parse_args() + require(args.mode != "candidate" or args.expected_complement_sha256 is not None, "Candidate requires the fresh baseline complement SHA-256 before execution") + require(args.expected_complement_sha256 is None or (args.mode != "finite" and len(args.expected_complement_sha256) == 64 and all(c in "0123456789abcdef" for c in args.expected_complement_sha256)), "Invalid or inapplicable expected complement SHA-256") + require(not args.output.exists(), "Refusing to overwrite earlier run evidence") + args.output.mkdir(parents=True) + require(source_check() == 25, "Frozen H changed") + if args.mode != "finite": + require(sys.flags.optimize == 0, "Complete measurements require all unchanged source assertions") + phases = {} + controls = None + native = None + build = None + if args.mode in ("finite", "candidate"): + wall, cpu = time.perf_counter(), cpu_seconds() + native, build = build_native(args.output / "cold-build") + phases["cold_compile_link_load"] = {"wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu} + wall, cpu = time.perf_counter(), cpu_seconds() + controls = run_controls(native) + phases["all_finite_independent_binding_fallback_controls"] = { + "wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu, + } + (args.output / "finite-controls.json").write_text(json.dumps(controls, indent=2, sort_keys=True) + "\n") + complete = None + binding = None + if args.mode != "finite": + rank_calls = [] + wall, cpu = time.perf_counter(), cpu_seconds() + module = load_source("_matrix_complete_" + args.mode) + complement_trace = ComplementTrace(module.Label) + if args.mode == "candidate": + binding = bind(module, native, rank_calls, complement_trace) + else: + guard_module(module) + attach_trace(module, rank_calls, complement_trace) + phases["cold_source_load_guard_bind"] = {"wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu} + result, witness = scientific_run(module, phases) + wall, cpu = time.perf_counter(), cpu_seconds() + complete = write_scientific(args.output, result, witness, rank_calls) + phases["same_complete_witness_trace_serialization"] = { + "wall_seconds": time.perf_counter() - wall, + "cpu_seconds_including_children": cpu_seconds() - cpu, + } + complete["result"] = result + complete["complement_trace"] = complement_trace.receipt() + require(complete["complement_trace"]["calls"] == 238685, "Complete ordered complement call coverage changed") + if args.expected_complement_sha256 is not None: + require(complete["complement_trace"]["sha256"] == args.expected_complement_sha256, "Complete complement stream differs from the fresh baseline") + (args.output / "complement-transcript.json").write_text(json.dumps(complete["complement_trace"], indent=2, sort_keys=True) + "\n") + if binding is not None: + expected_calls = {"complement_native": 238685, "complement_fallback": 0, + "gram_native": 59959, "gram_fallback": 0} + require(binding["counters"] == expected_calls, "Frozen complete native call coverage changed") + complete["native_calls"] = dict(binding["counters"]) + source_files = ("native_gf2.c", "native_backend.py", "finite_controls.py", + "compare_side_verifier.py", "profile_side_verifier.py") + sources = {name: hashlib.sha256((ROOT / name).read_bytes()).hexdigest() for name in source_files} + receipt = { + "status": "FINITE_PASS" if args.mode == "finite" else "COMPLETE_SIDE_PASS", + "mode": args.mode, + "qualification_revision": 2, + "expected_complement_sha256": args.expected_complement_sha256, + "base_main": "de5ec2e7a6074068452f45b1a191b5c72832df4a", + "frozen_sources": {"complex_circuit.py": SOURCE_SHA256, "complex_network.py": CALLER_SHA256}, + "engineering_sources": sources, + "complete": complete, + "controls": controls, + "build": build, + "phases": phases, + "measured_wall_seconds_before_receipt_write": time.perf_counter() - START_WALL, + "process_plus_compiler_cpu_seconds_before_receipt_write": cpu_seconds(), + "environment": {"python": sys.version, "executable": sys.executable, + "platform": sys.platform, "optimization": sys.flags.optimize}, + "measurement_scope": "Cold entire process; parent guard outer wall/CPU is authoritative. Both arms write identical complete witness bytes. Candidate additionally compiles, links, loads and runs every finite/native/binding control.", + "scientific_scope": "Frozen H=25 complex side verification only; no full network certificate, selected frontier, PR5864 gain, new construction, parameter search or kappa admission.", + } + (args.output / "receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(json.dumps({"status": receipt["status"], "mode": args.mode, + "wall_seconds": receipt["measured_wall_seconds_before_receipt_write"], + "cpu_seconds_with_compiler": receipt["process_plus_compiler_cpu_seconds_before_receipt_write"], + "complete_hashes": None if complete is None else {key: complete[key] for key in EXPECTED}, + "complement_trace": None if complete is None else complete["complement_trace"], + "controls": None if controls is None else controls["status"], + "phases": phases}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/native_backend.py b/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/native_backend.py new file mode 100644 index 0000000000..77e55ce9d0 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/native_backend.py @@ -0,0 +1,386 @@ +"""Source-bound packed GF(2), with a fail-closed stable-runtime boundary. + +Supported bindings use the literal frozen source, ordinary built-ins and the +original Label dispatch. Resolved method/helper globals and built-ins, helper +code/defaults/closures and class/native dispatch must remain unchanged after +binding. Calls run serially with no mutation during a call; detected boundary +drift is rejected before arithmetic or fallback. This is not a sandbox +against arbitrary mutation of this backend or native process memory. +""" +from __future__ import annotations + +import builtins +import hashlib +import importlib.util +import json +from pathlib import Path +import shlex +import subprocess +import sys +import sysconfig +from types import BuiltinFunctionType, CodeType, FunctionType, GetSetDescriptorType, ModuleType + +ROOT = Path(__file__).resolve().parent +SOURCE = ROOT / "source" / "complex_circuit.py" +SOURCE_SHA256 = "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" +CALLER_SHA256 = "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b" + +# Anchored operations keep drift checks independent of the source's lookup +# environment and avoid executing modified helper functions or descriptors. +_TYPE = type +_LEN = len +_INT = int +_DICT = dict +_LIST = list +_TUPLE = tuple +_OBJECT = object +_RUNTIME_ERROR = RuntimeError +_COMPILE = compile +_DICT_GET = dict.get +_DICT_VALUES = dict.values +_OBJECT_GETATTRIBUTE = object.__getattribute__ +_BUILTINS = builtins.__dict__ +_BUILTIN_NAMES = ("all", "enumerate", "len", "list", "max", "next", "range", + "sorted", "sum", "tuple", "int", "dict", "type", "object") +_CANONICAL_BUILTINS = {name: _BUILTINS[name] for name in _BUILTIN_NAMES} +_HELPER_NAMES = ("echelon", "reduce", "dot", "rank") +_TYPE_BUILTINS = {"list": _LIST, "tuple": _TUPLE, "int": _INT, + "dict": _DICT, "type": _TYPE, "object": _OBJECT} +_BIT_DESCRIPTORS = tuple((_INT, name, getattr(_INT, name)) for name in + ("bit_count", "bit_length", "__and__", "__xor__", "__lshift__", "__rshift__")) + + +def require(condition, message): + if not condition: + raise _RUNTIME_ERROR(message) + + +def _check_builtins(): + for name, expected in _CANONICAL_BUILTINS.items(): + require(_DICT_GET(_BUILTINS, name) is expected, "Runtime drift: builtin " + name) + if name in _TYPE_BUILTINS: + require(expected is _TYPE_BUILTINS[name], "Unexpected builtin type: " + name) + elif name in ("enumerate", "range"): + require(_TYPE(expected) is _TYPE and expected.__name__ == name and + expected.__module__ == "builtins" and not (expected.__flags__ & (1 << 9)), + "Unexpected builtin class: " + name) + else: + require(_TYPE(expected) is BuiltinFunctionType and expected.__name__ == name and + expected.__module__ == "builtins", "Unexpected builtin function: " + name) + for owner, name, descriptor in _BIT_DESCRIPTORS: + require(_TYPE.__getattribute__(owner, name) is descriptor, "Runtime drift: builtin integer semantics") + + +def verify_sources(): + raw = SOURCE.read_bytes() + require(hashlib.sha256(raw).hexdigest() == SOURCE_SHA256, "Frozen complex source changed") + caller = (ROOT / "source" / "complex_network.py").read_bytes() + require(hashlib.sha256(caller).hexdigest() == CALLER_SHA256, "Frozen caller source changed") + return raw + + +def load_source(name): + verify_sources() + spec = importlib.util.spec_from_file_location(name, SOURCE) + require(spec is not None and spec.loader is not None, "Missing frozen module loader") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def _code_shape(code): + """Compare source code using only exact immutable values, never user equality.""" + require(_TYPE(code) is CodeType, "Unexpected function code type") + def constant(value): + kind = _TYPE(value) + if value is None or value is Ellipsis: + return ("singleton", value is Ellipsis) + if kind is _INT or kind is bool or kind is str or kind is bytes: + return (kind.__name__, value) + if kind is _TUPLE: + return ("tuple", _TUPLE(constant(item) for item in value)) + if kind is CodeType: + return ("code", _code_shape(value)) + raise _RUNTIME_ERROR("Unexpected mutable or custom constant in frozen function") + fields = (code.co_argcount, code.co_posonlyargcount, code.co_kwonlyargcount, + code.co_nlocals, code.co_stacksize, code.co_flags, code.co_code, + code.co_names, code.co_varnames, code.co_freevars, code.co_cellvars, + code.co_exceptiontable, code.co_linetable, code.co_firstlineno, + code.co_filename, code.co_name, code.co_qualname, code.co_consts) + return _TUPLE(constant(value) for value in fields) + + +def guard_module(module): + """Validate code AND every resolved builtin/helper/Label dispatch owner.""" + _check_builtins() + raw = verify_sources() + require(_TYPE(module) is ModuleType, "Unexpected source module type") + namespace = module.__dict__ + require(_TYPE(_DICT_GET(namespace, "__file__")) is str and _TYPE(_DICT_GET(namespace, "__name__")) is str, "Unexpected source module metadata types") + require(Path(namespace["__file__"]).resolve() == SOURCE.resolve(), "Unexpected source module path") + require(_DICT_GET(namespace, "__builtins__") is _BUILTINS, "Changed source builtins owner") + for name in _BUILTIN_NAMES: + require(name not in namespace, "Source builtin shadow: " + name) + expected = _COMPILE(raw, str(SOURCE), "exec", dont_inherit=True, optimize=sys.flags.optimize) + codes = {code.co_name: code for code in expected.co_consts if _TYPE(code) is CodeType} + + def check(function, expected_code, name): + require(_TYPE(function) is FunctionType, "Non-function replacement: " + name) + require(function.__globals__ is namespace, "Changed function globals: " + name) + # A function captures its own builtins pointer when created; checking + # only the module's current __builtins__ slot would miss a forged one. + require(function.__builtins__ is _BUILTINS, "Changed effective function builtins: " + name) + require(function.__closure__ is None and function.__defaults__ is None and + function.__kwdefaults__ is None, "Changed function calling contract: " + name) + require(_code_shape(function.__code__) == _code_shape(expected_code), + "Changed frozen function code: " + name) + + for name in _HELPER_NAMES: + check(_DICT_GET(namespace, name), codes[name], name) + label = _DICT_GET(namespace, "Label") + require(_TYPE(label) is _TYPE and label.__mro__ == (label, _OBJECT), "Changed Label class shape") + require(_TYPE(label.__module__) is str and label.__module__ == module.__name__, "Changed Label module ownership") + methods = {code.co_name: code for code in codes["Label"].co_consts if _TYPE(code) is CodeType} + attributes = label.__dict__ + require(_LEN(attributes) == 4 + _LEN(methods), "Changed Label class attributes") + for name in ("__module__", "__doc__", "__dict__", "__weakref__"): + require(name in attributes, "Missing original Label descriptor") + for name in ("__dict__", "__weakref__"): + descriptor = attributes[name] + require(_TYPE(descriptor) is GetSetDescriptorType and descriptor.__objclass__ is label, + "Custom Label descriptor: " + name) + for name, code in methods.items(): + check(attributes.get(name), code, "Label." + name) + require(label.__getattribute__ is _OBJECT.__getattribute__ and label.__new__ is _OBJECT.__new__, + "Custom Label attribute or construction dispatch") + return label + + +class RuntimeGuard: + """Identity-only freshness checks; no modified callable is invoked.""" + def __init__(self, module, label, native, original_functions): + self.module = module + self.namespace = module.__dict__ + self.label = label + self.mro = label.__mro__ + self.class_items = _TUPLE(label.__dict__.items()) + self.global_items = _TUPLE((name, self.namespace[name]) for name in _HELPER_NAMES + ("Label", "__builtins__")) + functions = _LIST(original_functions) + functions.extend(value for _, value in self.class_items if _TYPE(value) is FunctionType) + functions.append(self.namespace["rank"]) + self.functions = _TUPLE((function, function.__code__, function.__globals__, function.__builtins__, + function.__defaults__, function.__kwdefaults__, function.__closure__, + () if function.__closure__ is None else + _TUPLE((cell, cell.cell_contents) for cell in function.__closure__)) + for function in functions) + self.native = native + require(_TYPE(native) is ModuleType, "Unexpected native module type") + self.native_items = _TUPLE((name, native.__dict__[name]) for name in ("gram_rank", "complement")) + for name, function in self.native_items: + require(_TYPE(function) is BuiltinFunctionType and function.__self__ is native, + "Changed native entry point: " + name) + self.check() + + def check(self): + # The source globals and Label remain a normal module and exact class; + # lookups below therefore do not invoke user-defined descriptors. + require(_TYPE(self.module) is ModuleType and self.module.__dict__ is self.namespace, + "Runtime drift: source module dispatch") + require(_TYPE(self.label) is _TYPE and self.label.__mro__ is self.mro, + "Runtime drift: Label class dispatch") + for name, value in self.global_items: + require(_DICT_GET(self.namespace, name) is value, "Runtime drift: source helper " + name) + for name, expected in _CANONICAL_BUILTINS.items(): + require(name not in self.namespace and _DICT_GET(_BUILTINS, name) is expected, + "Runtime drift: builtin lookup " + name) + attributes = self.label.__dict__ + require(_LEN(attributes) == _LEN(self.class_items), "Runtime drift: Label descriptors") + for name, value in self.class_items: + require(attributes.get(name) is value, "Runtime drift: Label member " + name) + for function, code, namespace, effective_builtins, defaults, kwdefaults, closure, cells in self.functions: + require(function.__code__ is code and function.__globals__ is namespace and + function.__builtins__ is effective_builtins and function.__defaults__ is defaults and + function.__kwdefaults__ is kwdefaults and function.__closure__ is closure, + "Runtime drift: function code or calling environment") + for cell, value in cells: + require(cell.cell_contents is value, "Runtime drift: wrapper closure") + require(_TYPE(self.native) is ModuleType, "Runtime drift: native module dispatch") + for name, function in self.native_items: + require(_DICT_GET(self.native.__dict__, name) is function, "Runtime drift: native entry point " + name) + + +class ComplementTrace: + """Stream every ordered complement input and typed output, without retention. + + Snapshotting is confined to the exact Label/exact dict/int domain of the + complete H25 workload. Finite fallback tests leave this observer disabled. + """ + def __init__(self, label): + self.label = label + self.count = 0 + self.bytes = 0 + self.hasher = hashlib.sha256() + + def before(self, small, big): + require(_TYPE(small) is self.label and _TYPE(big) is self.label, "Trace requires exact frozen Label objects") + big_dict = _OBJECT_GETATTRIBUTE(big, "__dict__") + small_dict = _OBJECT_GETATTRIBUTE(small, "__dict__") + require(_TYPE(big_dict) is _DICT and _TYPE(small_dict) is _DICT, "Trace requires ordinary instance dictionaries") + vs_basis = _DICT_GET(big_dict, "basis") + us_basis = _DICT_GET(small_dict, "basis") + require(_TYPE(vs_basis) is _DICT and _TYPE(us_basis) is _DICT, "Trace requires exact basis dictionaries") + vs = _TUPLE(_DICT_VALUES(vs_basis)) + us = _TUPLE(_DICT_VALUES(us_basis)) + require(all(_TYPE(value) is _INT for value in us + vs), "Trace requires exact integer vectors") + return us, vs + + def after(self, inputs, output): + us, vs = inputs + if output is None: + result = {"type": "None"} + else: + require(_TYPE(output) is _LIST and all(_TYPE(value) is _INT for value in output), + "Trace requires an exact integer list or None result") + result = {"type": "list", "values": output} + record = {"call": self.count, "us": us, "vs": vs, "result": result} + encoded = json.dumps(record, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + b"\n" + self.hasher.update(encoded) + self.bytes += _LEN(encoded) + self.count += 1 + + def receipt(self): + return {"calls": self.count, "canonical_stream_bytes": self.bytes, + "sha256": self.hasher.hexdigest(), + "schema": "v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors"} + + +def build_native(directory): + """Always cold compile/link/load once. The parent supplies the outer guard.""" + require(sys.implementation.name == "cpython" and sys.version_info[:2] == (3, 12), + "This qualification is frozen to CPython 3.12") + require(sys.platform.startswith("linux"), "This qualification is frozen to Linux") + directory = Path(directory) + require(not directory.exists(), "Refusing to reuse a native build directory") + directory.mkdir(parents=True) + source = ROOT / "native_gf2.c" + source_before = source.read_bytes() + source_hash = hashlib.sha256(source_before).hexdigest() + suffix = sysconfig.get_config_var("EXT_SUFFIX") + require(_TYPE(suffix) is str and suffix.endswith(".so"), "Unexpected extension suffix") + target = directory / ("_packed_gf2" + suffix) + compiler = shlex.split(sysconfig.get_config_var("CC") or "cc") + require(compiler, "Missing configured C compiler") + command = compiler + ["-shared", "-fPIC", "-O3", "-std=c11", "-Wall", "-Wextra", "-Werror", + "-I" + sysconfig.get_paths()["include"], str(source), "-o", str(target)] + completed = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, + text=True, timeout=90, check=False) + manifest = {"command": command, "returncode": completed.returncode, + "stdout": completed.stdout, "stderr": completed.stderr, + "c_source_sha256": source_hash, "python": sys.version, + "no_cached_binary": True} + (directory / "build.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") + require(completed.returncode == 0, "Native compilation failed; see build.json (no retry)") + require(source.read_bytes() == source_before, "Native source changed during compilation") + manifest["extension_sha256"] = hashlib.sha256(target.read_bytes()).hexdigest() + spec = importlib.util.spec_from_file_location("_packed_gf2", target) + require(spec is not None and spec.loader is not None, "Missing extension loader") + native = importlib.util.module_from_spec(spec) + spec.loader.exec_module(native) + (directory / "build.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") + return native, manifest + + +def attach_trace(module, rank_calls, complement_trace=None): + """Baseline observers; original arithmetic and return objects stay intact.""" + original_rank = module.rank + original_complement = module.Label.complement_in + + def traced_rank(rows): + frozen_rows = _TUPLE(rows) + answer = original_rank(frozen_rows) + require(_TYPE(answer) is _INT, "Rank output type changed") + rank_calls.append((frozen_rows, answer)) + return answer + + def traced_complement(self, other): + inputs = complement_trace.before(self, other) + answer = original_complement(self, other) + complement_trace.after(inputs, answer) + return answer + + module.rank = traced_rank + if complement_trace is not None: + module.Label.complement_in = traced_complement + return original_rank + + +def bind(module, native, rank_calls=None, complement_trace=None): + """Replace two methods only; any detected runtime drift is a hard failure.""" + require(_TYPE(native) is ModuleType, "Unexpected native module type") + native_complement = _DICT_GET(native.__dict__, "complement") + native_gram = _DICT_GET(native.__dict__, "gram_rank") + require(_TYPE(native_complement) is BuiltinFunctionType and native_complement.__self__ is native and + _TYPE(native_gram) is BuiltinFunctionType and native_gram.__self__ is native, + "Missing or replaced native entry points") + label = guard_module(module) + original_functions = [module.__dict__[name] for name in _HELPER_NAMES] + original_functions.extend(value for value in label.__dict__.values() if _TYPE(value) is FunctionType) + original_complement = label.complement_in + original_nondegenerate = label.nondegenerate + original_dot = module.dot + original_rank = module.rank + if rank_calls is not None: + attach_trace(module, rank_calls) + counters = {"complement_native": 0, "complement_fallback": 0, + "gram_native": 0, "gram_fallback": 0} + runtime = None + + def complement_in(self, other): + runtime.check() + inputs = None if complement_trace is None else complement_trace.before(self, other) + if _TYPE(self) is label and _TYPE(other) is label: + big_dict = _OBJECT_GETATTRIBUTE(other, "__dict__") + small_dict = _OBJECT_GETATTRIBUTE(self, "__dict__") + if _TYPE(big_dict) is _DICT and _TYPE(small_dict) is _DICT: + big = _DICT_GET(big_dict, "basis") + small = _DICT_GET(small_dict, "basis") + if _TYPE(big) is _DICT and _TYPE(small) is _DICT: + result = native_complement(small, big) + if result is not NotImplemented: + counters["complement_native"] += 1 + if complement_trace is not None: + complement_trace.after(inputs, result) + return result + counters["complement_fallback"] += 1 + result = original_complement(self, other) + if complement_trace is not None: + complement_trace.after(inputs, result) + return result + + def nondegenerate(self): + runtime.check() + if _TYPE(self) is label: + instance = _OBJECT_GETATTRIBUTE(self, "__dict__") + if _TYPE(instance) is _DICT: + basis = _DICT_GET(instance, "basis") + if _TYPE(basis) is _DICT: + answer = native_gram(basis) + if answer is not NotImplemented: + rows, rank = answer + if rank_calls is not None: + require(_TYPE(rank) is _INT, "Native rank output type changed") + rank_calls.append((rows, rank)) + counters["gram_native"] += 1 + return rank == _LEN(rows) + counters["gram_fallback"] += 1 + return original_nondegenerate(self) + + label.complement_in = complement_in + label.nondegenerate = nondegenerate + # Set the closure before capturing it, then initialize the guard in place. + # Thus every captured cell identity is its final stable value. + runtime = _OBJECT.__new__(RuntimeGuard) + RuntimeGuard.__init__(runtime, module, label, native, original_functions) + return {"counters": counters, "original_complement": original_complement, + "original_nondegenerate": original_nondegenerate, "original_dot": original_dot, + "original_rank": original_rank, "label": label, "runtime_guard": runtime} diff --git a/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/profile_side_verifier.py b/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/profile_side_verifier.py new file mode 100644 index 0000000000..807855eb87 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/profile_side_verifier.py @@ -0,0 +1,193 @@ +#!/usr/bin/env python3 +"""Diagnostic profile of an unchanged, frozen h=25 side verification scope. + +This is not complex_network.certificate(), a selected-frontier replay, a +construction search, or a performance qualification. Run only under the +parent's serial process-group guard. No compiler or third-party dependency. +""" +from __future__ import annotations + +import argparse +import ast +from collections import Counter +import cProfile +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import pstats +import sys +import time + +BASE_MAIN = "de5ec2e7a6074068452f45b1a191b5c72832df4a" +PINS = { + "complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1", + "complex_network.py": "0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b", +} +ROOT = Path(__file__).resolve().parent + + +def require(condition, message): + if not condition: + raise RuntimeError(message) + + +def canonical(value): + return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii") + + +def digest(value): + return hashlib.sha256(canonical(value)).hexdigest() + + +def source_check(): + for name, expected in PINS.items(): + actual = hashlib.sha256((ROOT / "source" / name).read_bytes()).hexdigest() + require(actual == expected, "Source digest changed: " + name) + tree = ast.parse((ROOT / "source" / "complex_network.py").read_text()) + hs = [ast.literal_eval(node.value) for node in tree.body + if isinstance(node, ast.Assign) and + any(isinstance(target, ast.Name) and target.id == "H" for target in node.targets)] + require(hs == [25], "The unchanged caller no longer freezes H=25") + return hs[0] + + +def run_side(h, rank_calls, phases): + def phase(name, action): + start_wall = time.perf_counter() + start_cpu = time.process_time() + value = action() + phases[name] = {"wall_seconds": time.perf_counter() - start_wall, + "cpu_seconds": time.process_time() - start_cpu} + return value + + def load(): + spec = importlib.util.spec_from_file_location("_frozen_matrix_complex_circuit", ROOT / "source" / "complex_circuit.py") + require(spec is not None and spec.loader is not None, "Cannot load frozen module") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + module = phase("load", load) + original_rank = module.rank + + def traced_rank(rows): + frozen_rows = tuple(rows) + result = original_rank(frozen_rows) + require(type(result) is int, "Rank result changed its exact type") + rank_calls.append((frozen_rows, result)) + return result + + module.rank = traced_rank + circuit = phase("construction", lambda: module.ComplexSideCircuit(h)) + checks = phase("checks_initialization", lambda: module.Checks(circuit)) + code = phase("compile_roles", lambda: module.compile_roles(circuit)) + side_map = phase("verify_map", checks.verify_map) + labels = phase("verify_labels", checks.verify_labels) + roles = phase("verify_role_frames", lambda: module.verify_role_frames(circuit, checks, code)) + # These are exactly the complete finite side checks called, in this order, + # by complex_network.certificate(). No mathematical parameters are varied. + result = {"circuit": circuit.stats(), "side_map": side_map, + "labels": labels, "role_frames": roles} + return circuit, checks, code, result + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args() + require(sys.flags.optimize == 0, "This source uses assert; profile must run without -O") + sys.dont_write_bytecode = True + require(not args.output.exists(), "Refusing to overwrite diagnostic evidence") + args.output.mkdir(parents=True) + h = source_check() + profile = cProfile.Profile() + rank_calls = [] + phases = {} + start_wall = time.perf_counter() + start_cpu = time.process_time() + circuit, checks, code, result = profile.runcall(run_side, h, rank_calls, phases) + profile_cpu = time.process_time() - start_cpu + profile_wall = time.perf_counter() - start_wall + profile.dump_stats(str(args.output / "profile.pstats")) + stats = pstats.Stats(profile) + targeted = [] + all_source = [] + for (filename, line, name), (primitive, total, self_time, cumulative, callers) in stats.stats.items(): + if filename.endswith("complex_circuit.py"): + row = {"name": name, "line": line, "primitive_calls": primitive, + "total_calls": total, "self_seconds": self_time, + "cumulative_seconds": cumulative} + all_source.append(row) + if name in {"rank", "echelon", "reduce", "dot", "complement_in", "nondegenerate"}: + targeted.append(row) + shape_counts = Counter((len(rows), max((x.bit_length() for x in rows), default=0)) + for rows, _ in rank_calls) + unique = {} + for rows, rank in rank_calls: + previous = unique.setdefault(rows, rank) + require(previous == rank, "Identical rank matrices produced different outputs") + # Preserve the ordered trace, exact rows and expected outputs. This frozen + # corpus enables a later conversion-plus-native check without a new search. + with (args.output / "rank-trace.jsonl").open("x", encoding="ascii") as output: + for rows, rank in rank_calls: + output.write(canonical({"rows": rows, "rank": rank}).decode("ascii") + "\n") + rank_corpus = [{"rows": rows, "rank": rank} for rows, rank in sorted(unique.items())] + (args.output / "rank-corpus.json").write_bytes(canonical(rank_corpus) + b"\n") + # Basis dictionary insertion order, labels, pivots, role order and coefficient + # numerators/denominators are all hashed without normalization of witnesses. + witnesses = { + "support": circuit.support, + "args": circuit.args, + "kind": circuit.kind, + "active": sorted(circuit.active), + "pieces": [(target, node, (coefficient.numerator, coefficient.denominator)) + for target, node, coefficient in circuit.pieces], + "labels": [(key, list(label.basis.items()), label.dim, label.key) + for key, label in checks.cache.items()], + "code": {"roles": code["roles"], "gates": code["gates"], + "sources": list(code["sources"].items()), + "outputs": list(code["outputs"].items())}, + } + receipt = { + "status": "DIAGNOSTIC_COMPLETE_SIDE_SCOPE_ONLY", + "base_main": BASE_MAIN, + "sources": PINS, + "unchanged_caller": "scripts/complex_network.py:certificate (side verification segment)", + "h": h, + "result": result, + "result_sha256": digest(result), + "exact_witness_sha256": digest(witnesses), + "rank_trace_sha256": digest(rank_calls), + "rank_call_count": len(rank_calls), + "rank_distinct_matrix_count": len(unique), + "rank_shape_counts": [{"rows": r, "columns": c, "calls": n} + for (r, c), n in sorted(shape_counts.items())], + "profiled_complete_side_wall_seconds": profile_wall, + "profiled_complete_side_cpu_seconds": profile_cpu, + "profiled_phases": phases, + "targeted_functions": sorted(targeted, key=lambda item: item["cumulative_seconds"], reverse=True), + "all_source_functions": sorted(all_source, key=lambda item: item["self_seconds"], reverse=True), + "environment": {"python": sys.version, "executable": sys.executable, + "platform": sys.platform, "pid": os.getpid()}, + "limitations": [ + "Profiled timings include cProfile and exact rank-trace instrumentation.", + "Cumulative times are nested and must not be summed.", + "No native code or candidate execution; no speedup established.", + "The complete side verification segment is not the full complex-network certificate.", + "No PR5864 workload is executed and no matrix time counts toward its improvement target.", + "No new construction, parameter search, kappa admission or formal theorem verification.", + ], + } + (args.output / "receipt.json").write_text(json.dumps(receipt, indent=2, sort_keys=True) + "\n") + print(json.dumps({"status": receipt["status"], "h": h, + "wall_seconds": profile_wall, "cpu_seconds": profile_cpu, + "rank_calls": len(rank_calls), "rank_distinct_matrices": len(unique), + "result_sha256": receipt["result_sha256"], + "exact_witness_sha256": receipt["exact_witness_sha256"], + "targeted_functions": receipt["targeted_functions"]}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-authentic-serializer-20261031/reviews/I1-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/reviews/I1-EVIDENCE-v1.json new file mode 100644 index 0000000000..6a8dbea6a3 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/reviews/I1-EVIDENCE-v1.json @@ -0,0 +1,47 @@ +{ + "files": { + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/API-v1.md": { + "bytes": 5012, + "mode_octal": "0o664", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/CONTROL-SPEC-v1.json": { + "bytes": 2002, + "mode_octal": "0o664", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PACKAGE-PINS-v1.json": { + "bytes": 1152, + "mode_octal": "0o664", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "mode_octal": "0o664", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json": { + "bytes": 2395, + "mode_octal": "0o664", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-READINESS-v1.json": { + "bytes": 2306, + "mode_octal": "0o664", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py": { + "bytes": 14650, + "mode_octal": "0o664", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py": { + "bytes": 13181, + "mode_octal": "0o664", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + } + }, + "passive_AST_control_count": 39, + "passive_AST_order_matches": true, + "schema": "o03-independent-I1-evidence-v1" +} diff --git a/research/h25-authentic-serializer-20261031/reviews/I1-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/reviews/I1-REVIEW-v1.json new file mode 100644 index 0000000000..c1a98b876a --- /dev/null +++ b/research/h25-authentic-serializer-20261031/reviews/I1-REVIEW-v1.json @@ -0,0 +1,97 @@ +{ + "accepted_checkpoint": "I1", + "activity_boundary": { + "controls_tests_benchmarks": 0, + "decompressions": 0, + "method": "Passive AST/source/text/metadata hashing only", + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_function_calls": 0, + "target_imports": 0 + }, + "checks": { + "consumer_API": "load_frozen_inputs(Path,custody)->dict result,witness,ranks,input_receipt; authenticate_inputs fresh transport-only receipt", + "controls": { + "count_per_mode": 39, + "executed": false, + "modes": [ + 0, + 1 + ], + "ordered_names": [ + "L01_valid_schema_types_order_fresh_ownership", + "L02_transport_hash_before_decode", + "L03_transport_size_before_decode", + "L04_invalid_gzip", + "L05_truncated_gzip", + "L06_logical_size_overrun", + "L07_logical_final_size_before_parse", + "L08_logical_digest_before_parse", + "L09_duplicate_json_keys", + "L10_nonfinite_json_nan", + "L11_nonfinite_json_infinity", + "L12_wrong_witness_key_set", + "L13_wrong_code_key_set", + "L14_unsupported_kind_leaf", + "L15_args_arity", + "L16_args_bool_int_rejected", + "L17_label_bad_tag", + "L18_label_tag_arity", + "L19_basis_order_retained", + "L20_gate_order_retained", + "L21_source_order_retained", + "L22_output_order_retained", + "L23_arbitrary_width_ints", + "L24_unchanged_decimal_error", + "L25_duplicate_rank_events_retained", + "L26_rank_row_bool_rejected", + "L27_rank_result_bool_rejected", + "L28_result_int_bool_rejected", + "L29_result_float_not_int", + "L30_result_nonfinite_float_rejected", + "L31_wrong_rank_count", + "L32_wrong_distinct_count", + "L33_mode_drift_no_cached_pass", + "L34_byte_drift_no_cached_pass", + "L35_symlink_rejected", + "L36_hardlink_rejected", + "L37_before_after_mode_drift", + "L38_before_after_byte_drift", + "L39_numeric_float_overflow" + ], + "source_order_independently_matches_spec": true + }, + "custody": "Exact top-level, directory/path and nested identity keys; canonical absolute path; real0555 directories; unique regular0444 files, nofollow held-fd binding; actual metadata and hashes fresh before/after; no cached PASS", + "failure_cleanup": "No PASS on first failure; file/gzip context cleanup; finite fixtures finally cleaned; genuine failure evidence is parent-owned", + "full_fixed_transports_logical_hashes_sizes": "Literal original pins unchanged; authenticate before parse, <=1MiB logical chunks and size+1 sentinel; final digest/size before parse", + "restoration": "Exact seven witness keys, four code keys; source tuple arities restored without normalization; basis/gate/source/output order retained; ordered duplicate rank events retained; fixed59959 events/252 distinct rows", + "result": "Exactly original four-field certificate projection; exact-int fields reject bool; declared bool fields retain True/False; roles_per_target remains exact finite float", + "scientific_work": "No source imports/calls original scientific construction; no saved mathematical or bounded serializer claim", + "strict_json": "Duplicate keys, NaN/Infinity constants and floating overflow reject; default arbitrary-width integer/decimal limit semantics retained" + }, + "complete_precise_scope": "Isolated authentic fixed-pin loader, complete strict JSON/source-schema restoration and its 39 concrete ordered loader control cases in each declared mode 0 and 1, source only. This entire stated lane scope is accepted; no conditional source acceptance.", + "created_utc": "2026-10-31T08:11:45.533047+00:00", + "decision": "ACCEPT", + "execution_admitted": false, + "invalidation": "Any changed accepted source/spec/pins invalidates I1 dependent acceptance; stage/runtime changes require separate review.", + "lane": "I1", + "limitations": [ + "Author working copies0664 are externally hash-pinned at this instant, not future immutable execution custody. Q2/I3 and parent staging must establish new0444 source/input copies and actual runtime/provider/effective-binding seal.", + "No genuine payload decoded; actual schema acceptance, old/new controls, candidate bounded fast path, runtime identity, memory/CPU/wall/180s/1GiB fit, full consumer, execution or O03 qualification established.", + "I1 acceptance does not waive any Q1-Q5 or P0-P5 dependency; I2/I3/I4/I5-I7 remain separate. Original O02/O08/O09/O10 stay unchanged and open." + ], + "retained_review_observations": [ + { + "disposition": "Draft gap addressed before frozen packet by finite parse_float and L39; no target invocation", + "item": "JSON numeric overflow" + }, + { + "disposition": "Reviewer concern withdrawn after frozen-source reread confirmed _exact_keys already present; no revision/repair required", + "item": "Nested identity extra-key claim" + } + ], + "schema": "o03-independent-I1-source-review-v1", + "source_evidence": "I1-EVIDENCE-v1.json" +} diff --git a/research/h25-authentic-serializer-20261031/reviews/I2-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/reviews/I2-EVIDENCE-v1.json new file mode 100644 index 0000000000..23621cd1ca --- /dev/null +++ b/research/h25-authentic-serializer-20261031/reviews/I2-EVIDENCE-v1.json @@ -0,0 +1,176 @@ +{ + "files": { + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "mode_octal": "0o444", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONTROL-SPEC.json": { + "bytes": 3062, + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json": { + "bytes": 3934, + "mode_octal": "0o444", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PACKAGE-PINS-v1.json": { + "bytes": 2453, + "mode_octal": "0o444", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "mode_octal": "0o444", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "mode_octal": "0o444", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/README-v1.md": { + "bytes": 6609, + "mode_octal": "0o444", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/SOURCE-READINESS-v1.json": { + "bytes": 2081, + "mode_octal": "0o444", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py": { + "bytes": 9411, + "mode_octal": "0o444", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py": { + "bytes": 2141, + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py": { + "bytes": 6630, + "mode_octal": "0o444", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py": { + "bytes": 14577, + "mode_octal": "0o444", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + } + }, + "imports": { + "bounded_serialization.py": [ + "__future__", + "_json", + "contextlib", + "hashlib", + "json", + "os", + "pathlib", + "stat", + "tempfile", + "types" + ], + "full_consumer.py": [ + "__future__", + "argparse", + "bounded_serialization", + "frozen_h25_inputs", + "hashlib", + "json", + "os", + "pathlib", + "reference", + "stat", + "sys", + "time" + ], + "reference.py": [ + "hashlib", + "json" + ], + "run_controls.py": [ + "__future__", + "argparse", + "bounded_serialization", + "copy", + "full_consumer", + "hashlib", + "json", + "pathlib", + "reference", + "serialization_controls", + "sys", + "types" + ], + "serialization_controls.py": [ + "__future__", + "bounded_serialization", + "copy", + "hashlib", + "json", + "pathlib", + "sys", + "types" + ], + "validate_outputs.py": [ + "__future__", + "argparse", + "gzip", + "hashlib", + "json", + "os", + "pathlib", + "stat", + "sys" + ] + }, + "independent_validator_EXPECTED_literal_equal": true, + "independent_validator_canonical_AST_equal": true, + "new_control_count": 15, + "new_control_order": [ + "legitimate-bool-float-slots", + "ordered-duplicate-ranks", + "literal-fallback-no-credit", + "int-only-rank-bool-fallback-no-credit", + "missing-marker-no-credit", + "faults-enabled-no-credit", + "incomplete-phase-no-credit", + "missing-batches-no-credit", + "oversize-batch-no-credit", + "wrong-copy-limit-no-credit", + "missing-file-counter-no-credit", + "wrong-byte-counter-no-credit", + "digest-copy-mismatch-no-credit", + "incomplete-cleanup-no-credit", + "missing-stage-no-credit" + ], + "original_four_byte_exact": { + "CONTROL-SPEC.json": true, + "bounded_serialization.py": true, + "reference.py": true, + "serialization_controls.py": true + }, + "schema": "o03-independent-I2-evidence-v1", + "source_AST_parsed": [ + "bounded_serialization.py", + "full_consumer.py", + "reference.py", + "run_controls.py", + "serialization_controls.py", + "validate_outputs.py" + ] +} diff --git a/research/h25-authentic-serializer-20261031/reviews/I2-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/reviews/I2-REVIEW-v1.json new file mode 100644 index 0000000000..6420292636 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/reviews/I2-REVIEW-v1.json @@ -0,0 +1,81 @@ +{ + "accepted_checkpoint": "I2", + "activity_boundary": { + "controls_tests_benchmarks": 0, + "decompressions": 0, + "method": "Passive text/AST/hash/metadata only", + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_calls": 0, + "target_imports": 0 + }, + "checks": { + "actual_full_arm": "Optimization0; fresh input/root/process contract; unmodified original write_scientific and canonical and five-field EXPECTED; no finite oracle replacement in genuine arm", + "candidate": "Production make_writer faults false; BOUNDED_SERIALIZATION_PASS/complete;1MiB batch/copy and1024 rows; actual bounded counters/digests; literal fallback explicitly rejected for bounded credit; private stage removed and exactly3 finals", + "cleanup_failures": "Failure propagates; consumer attempts bounded additive failure receipt and preserves partial/failure artifacts; source/context cleanup and process exit must be included by envelope", + "complete_artifacts": "527/58143622/2674272 sizes; all3 original digests;59959 ordered events/252 distinct rows; local bounded file readback then fresh full transport postcheck", + "controls": { + "coverage": "Two concrete positive bounded writes, two concrete fallback writes denied bounded credit,11 mutated acceptance rejection cases; broader proof or unlisted variants not claimed", + "executed": false, + "modes": [ + 0, + 1 + ], + "new_count_per_mode": 15, + "new_order": [ + "legitimate-bool-float-slots", + "ordered-duplicate-ranks", + "literal-fallback-no-credit", + "int-only-rank-bool-fallback-no-credit", + "missing-marker-no-credit", + "faults-enabled-no-credit", + "incomplete-phase-no-credit", + "missing-batches-no-credit", + "oversize-batch-no-credit", + "wrong-copy-limit-no-credit", + "missing-file-counter-no-credit", + "wrong-byte-counter-no-credit", + "digest-copy-mismatch-no-credit", + "incomplete-cleanup-no-credit", + "missing-stage-no-credit" + ], + "old_count_per_mode": 70, + "old_source_and_spec_byte_exact": true + }, + "unchanged_originals": { + "CONTROL-SPEC.json": true, + "bounded_serialization.py": true, + "reference.py": true, + "serialization_controls.py": true + }, + "validator_independence": "No loader/consumer/candidate/reference import; literal original canonical AST and independent EXPECTED equal; new pinned transport authentication, complete logical witness/rank comparison against both outputs, small result projection, fresh rank count/type/distinct validation, complete receipts/counters/cleanup and after transport custody" + }, + "complete_precise_scope": "Complete authentic retained-value baseline/candidate consumer, separate independent bounded validator, unchanged original70 controls and concrete new15 controls per declared mode, source only. Entire explicit I2 source scope met.", + "created_utc": "2026-10-31T08:12:43.634715+00:00", + "decision": "ACCEPT", + "execution_admitted": false, + "invalidation": "Any source/dependency/spec/pins change invalidates dependent acceptance; stage/runtime operation must be reviewed separately.", + "lane": "I2", + "limitations": [ + "No target import/call/control/decode/decompression/benchmark or actual full-data result validated.", + "Source working packet0444 is read back now; separately owned immutable stage/runtime/custody/guard/observer/exact operation closure remain I3/I4 requirements.", + "Source acceptance is not execution admission, actual old/new controls, genuine fast-path eligibility, measured180s/1GiB fit, O03 qualification or original-caller/whole-goal credit.", + "Q1-Q5 and P0-P5 retained; no unrelated O08 or global O09 obligation added to O03." + ], + "loader_dependency": { + "independently_accepted": "I1-REVIEW-v1.json", + "path": "../loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "retained_review_findings": [ + { + "counterexample": "Newly written regular file first read under relatime can advance atime; complete stat equality would falsely reject unmodified output. No target run performed.", + "disposition": "Corrected before frozen36002d24... to explicit file_identity excluding atime; no frozen-package repair required", + "item": "Draft full stat comparisons included access time" + } + ], + "schema": "o03-independent-I2-source-review-v1", + "source_evidence": "I2-EVIDENCE-v1.json" +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/CURRENT-STATUS-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/CURRENT-STATUS-v2.json new file mode 100644 index 0000000000..6c5ec2ca9d --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/CURRENT-STATUS-v2.json @@ -0,0 +1,21 @@ +{ + "current_status": "INVALIDATED_KNOWN_INCOMPLETE_NOT_CURRENTLY_ADMITTED", + "current_valid_checkpoints": 2, + "current_valid_source_lanes": [ + "I1", + "I2" + ], + "failure_acceptance_credit": 0, + "historical_I3_source_acceptance": "Preserved unchanged in validation/source-reviews/I3-REVIEW-v2.json", + "historical_I4_authorization": "Authorized once-only dispatch was fail-closed; consumed failed and closed, not retroactively unauthorized.", + "historical_high_water": 4, + "known_failures": [ + "Actual mapped /usr/lib/locale/locale-archive absent from admitted runtime map closure.", + "Declared closing readback cannot parse preserved GNUtime nonzero diagnostic prefix; no successful readback report." + ], + "local_denominator": 8, + "packet": "envelope/19 exact source/spec/runtime members plus SOURCE-READINESS-v2.json", + "runtime_absolute_paths": "Host identity evidence; fresh host/path/runtime/custody/ledger/operation require new explicit authorization and review.", + "schema": "o03-failed-envelope-current-status-v2", + "source_repair_or_retry_authorized": false +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/ADMISSION-TEMPLATE-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/ADMISSION-TEMPLATE-v2.json new file mode 100644 index 0000000000..d06541be63 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/ADMISSION-TEMPLATE-v2.json @@ -0,0 +1,534 @@ +{ + "canonical_ledger": { + "cap_seconds": 2400, + "fresh_files": { + "PARENT_FILL_EVERY_CANONICAL_LEDGER_POLICY_AND_PRIOR_ATTEMPT_PATH": { + "sha256": "PARENT_FILL", + "size": "PARENT_FILL" + } + }, + "lock_path": "PARENT_FILL_ACTUAL_CANONICAL_LOCK", + "spent_seconds": "PARENT_REFRESH_CANONICAL_NOT_HISTORICAL_94.210533479" + }, + "consumed_marker": "PARENT_FILL_ABSOLUTE_FRESH_CONSUMED_MARKER", + "envelope_source_files": { + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py": { + "mode": 292, + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py": { + "mode": 292, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py": { + "mode": 292, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py": { + "mode": 292, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py": { + "mode": 292, + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py": { + "mode": 292, + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py": { + "mode": 292, + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py": { + "mode": 292, + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py": { + "mode": 292, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py": { + "mode": 292, + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + } + }, + "fixed_order": [ + "complete-fixed-o03" + ], + "independent_source_accepted": false, + "input_sources": { + "baseline/evidence/canonical/complex-network.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "size": 5662 + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "size": 22029 + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "size": 16995263 + } + }, + "interpreter": "/usr/bin/python3.12", + "maximum_command_seconds": 180, + "operation": "complete-fixed-o03", + "operation_root": "PARENT_FILL_ABSOLUTE_FRESH_OPERATION_ROOT", + "package_sources": { + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583", + "size": 736 + }, + "consumer/CONTROL-SPEC.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423", + "size": 3062 + }, + "consumer/DEPENDENCIES-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69", + "size": 3934 + }, + "consumer/PACKAGE-PINS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PACKAGE-PINS-v1.json", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc", + "size": 2453 + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-ATTEMPTS-v1.json", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875", + "size": 719 + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-CHECKS-v1.json", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381", + "size": 2637 + }, + "consumer/README-v1.md": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/README-v1.md", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7", + "size": 6609 + }, + "consumer/SOURCE-READINESS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/SOURCE-READINESS-v1.json", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606", + "size": 2081 + }, + "consumer/bounded_serialization.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "size": 23560 + }, + "consumer/full_consumer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688", + "size": 9411 + }, + "consumer/reference.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968", + "size": 2141 + }, + "consumer/run_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf", + "size": 6630 + }, + "consumer/serialization_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "size": 23684 + }, + "consumer/validate_outputs.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e", + "size": 14577 + }, + "envelope/ELF-CLOSURE-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/ELF-CLOSURE-v2.json", + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "size": 8733 + }, + "envelope/FIXED-SEQUENCE-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/FIXED-SEQUENCE-v2.json", + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf", + "size": 5379 + }, + "envelope/RUNTIME-PINS-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "size": 28663 + }, + "envelope/bootstrap.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py", + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "envelope/custody.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "envelope/effective.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "envelope/loader_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "envelope/observer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py", + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "envelope/observer_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py", + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "envelope/observer_fixture.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py", + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "envelope/parent_readback.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py", + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "envelope/sequence_worker.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "envelope/worker.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py", + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + }, + "loader/API-v1.md": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/API-v1.md", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677", + "size": 5012 + }, + "loader/CONTROL-SPEC-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/CONTROL-SPEC-v1.json", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c", + "size": 2002 + }, + "loader/PACKAGE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PACKAGE-PINS-v1.json", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71", + "size": 1152 + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PASSIVE-ATTEMPTS-v1.json", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4", + "size": 586 + }, + "loader/SOURCE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e", + "size": 2395 + }, + "loader/SOURCE-READINESS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-READINESS-v1.json", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f", + "size": 2306 + }, + "loader/frozen_h25_inputs.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a", + "size": 14650 + }, + "loader/frozen_input_controls.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c", + "size": 13181 + }, + "provenance/anchor.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "size": 1926 + }, + "provenance/canonical-MANIFEST.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "size": 1912 + } + }, + "parent_execution_admitted": false, + "runtime_manifest": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "runtime_sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "sampled_group_cap_bytes": 1073741824, + "schema": "o03-envelope-admission-v1", + "sequence": [ + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}", + "--runtime-manifest", + "{runtime_manifest}", + "--runtime-sha256", + "{runtime_sha256}" + ], + "effective_package_preloads": [], + "entry": "envelope/observer_controls.py", + "id": "observer-controls", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "case_count": 6, + "ordered_cases": [ + "bounded-child-allocation", + "concurrent-parent-child-allocation", + "short-lived-child", + "timeout-kill-reap", + "pid-membership-and-reaped-cleanup", + "sampled-cap-kill-reap" + ], + "status": "PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "count": 39, + "optimize": 0, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 0, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "count": 39, + "optimize": 1, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 1, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--arm", + "baseline", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference" + ], + "entry": "consumer/full_consumer.py", + "id": "baseline-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "baseline", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--arm", + "candidate", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference", + "bounded_serialization" + ], + "entry": "consumer/full_consumer.py", + "id": "candidate-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "candidate", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--baseline-root", + "{baseline_root}", + "--candidate-root", + "{candidate_root}", + "--baseline-receipt", + "{baseline_receipt}", + "--candidate-receipt", + "{candidate_receipt}", + "--report", + "{receipt}" + ], + "effective_package_preloads": [], + "entry": "consumer/validate_outputs.py", + "id": "independent-validation", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "status": "COMPLETE_OUTPUTS_VALIDATED" + } + } + ], + "worker": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py" +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/ELF-CLOSURE-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/ELF-CLOSURE-v2.json new file mode 100644 index 0000000000..4074522ce3 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/ELF-CLOSURE-v2.json @@ -0,0 +1,280 @@ +{ + "actual_dynamic_binding": "Prospective until admitted runtime before/after actual module/maps checks; env-i wrappers use pinned loader+DT_NEEDED under trusted local host loader/cache assumption", + "files": { + "/usr/bin/env": { + "elf_class": "ELF64_LSB", + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "interpreter_resolved": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 493, + "sha256": "886e5fa8be716b03eeda48856e0f04493f2969fc148fb7812594ffac647fa050", + "size": 48072 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/bin/python3.12": { + "elf_class": "ELF64_LSB", + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "interpreter_resolved": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "needed": [ + "libm.so.6", + "libz.so.1", + "libexpat.so.1", + "libc.so.6" + ], + "pin": { + "mode": 493, + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + "size": 8020928 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6", + "libexpat.so.1": "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1", + "libm.so.6": "/usr/lib/x86_64-linux-gnu/libm.so.6", + "libz.so.1": "/usr/lib/x86_64-linux-gnu/libz.so.1.3" + } + }, + "/usr/bin/time": { + "elf_class": "ELF64_LSB", + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "interpreter_resolved": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 493, + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10", + "size": 27160 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/bin/timeout": { + "elf_class": "ELF64_LSB", + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "interpreter_resolved": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 493, + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52", + "size": 39880 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libbz2.so.1.0", + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76", + "size": 32112 + }, + "resolved_dependencies": { + "libbz2.so.1.0": "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4", + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libcrypto.so.3", + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe", + "size": 64368 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6", + "libcrypto.so.3": "/usr/lib/x86_64-linux-gnu/libcrypto.so.3" + } + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [], + "pin": { + "mode": 420, + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3", + "size": 48952 + }, + "resolved_dependencies": {} + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "liblzma.so.5", + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7", + "size": 49256 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6", + "liblzma.so.5": "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5" + } + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907", + "size": 19432 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [], + "pin": { + "mode": 493, + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da", + "size": 236616 + }, + "resolved_dependencies": {} + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1", + "size": 78944 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "elf_class": "ELF64_LSB", + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "interpreter_resolved": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "needed": [ + "ld-linux-x86-64.so.2" + ], + "pin": { + "mode": 493, + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf", + "size": 2129424 + }, + "resolved_dependencies": { + "ld-linux-x86-64.so.2": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2" + } + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a", + "size": 5309400 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d", + "size": 186624 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d", + "size": 202904 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6", + "ld-linux-x86-64.so.2" + ], + "pin": { + "mode": 420, + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0", + "size": 952616 + }, + "resolved_dependencies": { + "ld-linux-x86-64.so.2": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "elf_class": "ELF64_LSB", + "interpreter": null, + "needed": [ + "libc.so.6" + ], + "pin": { + "mode": 420, + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242", + "size": 113000 + }, + "resolved_dependencies": { + "libc.so.6": "/usr/lib/x86_64-linux-gnu/libc.so.6" + } + } + }, + "method": "Passive ELF64 program-header/PT_INTERP/DT_NEEDED byte parsing of exact named binaries only; no ldd/compiler/native target/helper/process inspection", + "no_RPATH_analysis_claim": true, + "roots": [ + "/usr/bin/env", + "/usr/bin/timeout", + "/usr/bin/time", + "/usr/bin/python3.12" + ], + "schema": "o03-static-native-closure-v2" +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/FIXED-SEQUENCE-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/FIXED-SEQUENCE-v2.json new file mode 100644 index 0000000000..adb28bd936 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/FIXED-SEQUENCE-v2.json @@ -0,0 +1,213 @@ +{ + "schema": "o03-fixed-sequence-source-v1", + "sequence": [ + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}", + "--runtime-manifest", + "{runtime_manifest}", + "--runtime-sha256", + "{runtime_sha256}" + ], + "effective_package_preloads": [], + "entry": "envelope/observer_controls.py", + "id": "observer-controls", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "case_count": 6, + "ordered_cases": [ + "bounded-child-allocation", + "concurrent-parent-child-allocation", + "short-lived-child", + "timeout-kill-reap", + "pid-membership-and-reaped-cleanup", + "sampled-cap-kill-reap" + ], + "status": "PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "count": 39, + "optimize": 0, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 0, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "count": 39, + "optimize": 1, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 1, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--arm", + "baseline", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference" + ], + "entry": "consumer/full_consumer.py", + "id": "baseline-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "baseline", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--arm", + "candidate", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference", + "bounded_serialization" + ], + "entry": "consumer/full_consumer.py", + "id": "candidate-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "candidate", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--baseline-root", + "{baseline_root}", + "--candidate-root", + "{candidate_root}", + "--baseline-receipt", + "{baseline_receipt}", + "--candidate-receipt", + "{candidate_receipt}", + "--report", + "{receipt}" + ], + "effective_package_preloads": [], + "entry": "consumer/validate_outputs.py", + "id": "independent-validation", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "status": "COMPLETE_OUTPUTS_VALIDATED" + } + } + ] +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/OPERATION-BILL-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/OPERATION-BILL-v2.json new file mode 100644 index 0000000000..0fa6334221 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/OPERATION-BILL-v2.json @@ -0,0 +1,113 @@ +{ + "authentic_input_staging": { + "additional_full_input_hashes": "before/after source and copied-file custody, loader before/after, consumer postcheck, validator independent twice and coordinator custody; all paid", + "bytes_per_copy": 17022954, + "copies": 3, + "copy_read_bytes": 51068862, + "copy_write_bytes": 51068862 + }, + "baseline_writer": { + "encoded_write_hash_bytes_each": 60818421 + }, + "candidate_writer": { + "copy_read_final_write_hash_bytes_each": 60818421, + "private_stage_write_hash_bytes_each": 60818421, + "total_hash_bytes": 121636842, + "total_write_bytes": 121636842 + }, + "canonical_policy_charge": "full GNUtime outer wall+0.01s rounding quantum, never observer timer only", + "controls": { + "all_faults_and_cleanup": "included; first failure stops sequence", + "fixed_timeout_fixture_seconds": 2, + "loader_O": 39, + "loader_normal": 39, + "new_consumer_O": 15, + "new_consumer_normal": 15, + "observer": 6, + "observer_allocation_bytes": 117440512, + "observer_hold_seconds_per_allocation": 0.2, + "old_consumer_O": 70, + "old_consumer_normal": 70, + "orphan_processes_created": 0 + }, + "each_arm_loader": { + "additional_consumer_transport_rehash_bytes": 17022954, + "gzip_transport_reread_bytes": 17017292, + "local_final_output_read_hash_bytes": 60818421, + "logical_bytes": 60823556, + "plain_certificate_reread_bytes": 5662, + "restoration_and_rank_set": "full genuine witness/result/ranks;59959 events252 rows", + "transport_hash_bytes": 34045908, + "transport_hash_passes_before_after": 2 + }, + "finite_tail": { + "cost": "OPEN_NOT_ZERO", + "final_observer_writes": 1, + "includes": "final observer record and outer-time readback; parent ledger reconciliation/adjudication/publication separately OPEN_NOT_ZERO", + "parent_readback_operations": 1 + }, + "fixed_sequence": [ + "observer-controls", + "loader-controls-normal", + "consumer-controls-normal", + "loader-controls-O", + "consumer-controls-O", + "baseline-first", + "candidate-first", + "independent-validation" + ], + "fresh_budget_seconds": 0, + "guarded_commands": 1, + "historical_setup_seconds": 94.210533479, + "independent_validator": { + "both_output_final_compare_read_bytes": 121636842, + "logical_bytes": 60823556, + "rank_logical_retained_parse_bytes": 2674272, + "result_literal_projection_bytes": 527, + "transport_custody_hash_bytes": 34045908, + "transport_logical_reread_bytes": 17022954 + }, + "measurement": "continuous outer sampled simultaneous parent+descendant RSS; full lifetime SELF+waited-descendant CPU; wrapper GNU time wall/CPU/individual maxRSS; no cgroup peak", + "native_closure": "ELF-CLOSURE-v2.json passive exact17file PT_INTERP+DT_NEEDED; env/time/timeout/libc/loader pinned", + "other_unknown_not_zero": [ + "all actual wall/CPU/peak and sampling missed peaks", + "stdlib tempfile setup filesystem probes", + "source/runtime/metadata/control/failure I/O and repeated hashes", + "physical device/cache traffic", + "historical gaps and whole-goal costs" + ], + "per_command_wall_limit_seconds": 180, + "runtime": "observer+coordinator+8worker+8bootstrap+all fixture descendants exact before/after runtime/module/map/selected/effective checks; per-arm actual loader/candidate module preloads before seals; every successful fixed child reaped", + "sampled_rss_cap_bytes": 1073741824, + "schema": "o03-inclusive-complete-operation-bill-v2", + "source_only": true, + "source_package": { + "additional_authentication_reads": "stage source before/after, each copied file hash, complete package snapshot before/after/target bootstrap and fixture checks; all included, never free", + "bytes": 245041, + "files": 37, + "fresh_copies": 8, + "stage_copy_read_and_write_bytes_each_direction": 1960328 + }, + "source_repair": { + "added_package_members": [ + "loader/API-v1.md", + "loader/CONTROL-SPEC-v1.json", + "loader/PACKAGE-PINS-v1.json", + "loader/PASSIVE-ATTEMPTS-v1.json", + "loader/SOURCE-PINS-v1.json", + "loader/SOURCE-READINESS-v1.json", + "consumer/CONSUMER-CONTROL-SPEC-v1.json", + "consumer/CONTROL-SPEC.json", + "consumer/DEPENDENCIES-v1.json", + "consumer/PACKAGE-PINS-v1.json", + "consumer/PASSIVE-ATTEMPTS-v1.json", + "consumer/PASSIVE-CHECKS-v1.json", + "consumer/README-v1.md", + "consumer/SOURCE-READINESS-v1.json" + ], + "count": 1, + "effective_preloads": "source-fixed actual module names before per-entry effective seal; validator none", + "reason": "I3v1 omitted source-bound control specification JSON from immutable stage; exact complete accepted loader/consumer packets now included" + }, + "total_allowance_seconds": 2400 +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/PASSIVE-CHECKS-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/PASSIVE-CHECKS-v2.json new file mode 100644 index 0000000000..87be6e4c71 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/PASSIVE-CHECKS-v2.json @@ -0,0 +1,88 @@ +{ + "method": "AST and exact source/file metadata + static ELF byte parsing only", + "process_inspections": 0, + "repair_count": 1, + "sources": [ + { + "ast_parse": true, + "mode": 292, + "name": "bootstrap.py", + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + { + "ast_parse": true, + "mode": 292, + "name": "custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + { + "ast_parse": true, + "mode": 292, + "name": "effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + { + "ast_parse": true, + "mode": 292, + "name": "loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + { + "ast_parse": true, + "mode": 292, + "name": "observer.py", + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + { + "ast_parse": true, + "mode": 292, + "name": "observer_controls.py", + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + { + "ast_parse": true, + "mode": 292, + "name": "observer_fixture.py", + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + { + "ast_parse": true, + "mode": 292, + "name": "parent_readback.py", + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + { + "ast_parse": true, + "mode": 292, + "name": "sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + { + "ast_parse": true, + "mode": 292, + "name": "worker.py", + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + } + ], + "static_predicates": { + "all10_sources_AST_parse": true, + "all_control_specs_staged": true, + "fullarm_effective_preloads_declared": true, + "no_orphan_fixture_branch": true, + "same_fixed8_sequence": true, + "validator_no_effective_package_preloads": true + }, + "target_executions": 0, + "target_imports": 0, + "tests_controls_benchmarks": 0 +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/README-v2.md b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/README-v2.md new file mode 100644 index 0000000000..d93c4fa4e0 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/README-v2.md @@ -0,0 +1,37 @@ +# Fixed O03 execution source + +REPAIRED ONCE: v2 source; rejected v1 bytes and formal rejection remain preserved. SOURCE ONLY. No control, target import, staging, decode, process inspection or benchmark has been executed here. The independently accepted I1/I2 loader/consumer sources are dependencies. This packet requests I3 source review only; it grants no execution or O03 credit. + +The only proposed operation is `complete-fixed-o03`: six observer controls;39 loader cases normal;70 original+15 consumer cases normal;39 loader cases -O;70 original+15 consumer cases -O; first optimization0 baseline; first optimization0 candidate; separate independent full validator. The source order is FIXED-SEQUENCE-v2.json. All eight children are serial and reaped; every command belongs to one inclusive <=180-second guarded operation. No adaptive split, retry, reroll or smaller data substitute is authorized. Cap failure preserves this first attempt. Source-reviewed separate-stage use would require new explicit parent admission, not silent fallback. + +Parent fills ADMISSION-TEMPLATE-v2.json only after independent source acceptance and refreshed canonical ledger admission. Replace its administrative placeholders with exact absolute fresh paths/ledger hashes, preserve the entire source-frozen `sequence`, source/input pins, interpreter and caps, and independently anchor the final admission SHA256. Set both acceptance booleans true only after their respective approvals. `canonical_ledger.fresh_files` must cover every actual ledger/policy/prior-attempt record needed to establish current spent seconds, including incomplete attempts; `lock_path` must be the actual existing canonical writer lock used by all other guarded work. The observer takes that same nonblocking exclusive lock. Parent must stop other work, reconcile any unclosed prior attempt first, and add this observer receipt's full policy charge to the canonical ledger before any future operation. No alternate local allowance is created;94.210533479 is only the setup historical value. + +Exact command shape (all paths absolute and the digest filled from the final independently admitted metadata): + +``` +/usr/bin/env -i PATH=/usr/bin:/bin LC_ALL=C.UTF-8 TZ=UTC /usr/bin/timeout --signal=TERM --kill-after=1s 179s /usr/bin/time -f '{"wall_seconds":%e,"user_seconds":%U,"system_seconds":%S,"kernel_individual_maxrss_kib":%M,"exit":%x}' -o ABSOLUTE_PARENT_CONTROL_PATH/outer-time.json -- /usr/bin/python3.12 -B -I -S ABSOLUTE_ENVELOPE_PATH/observer.py --admission ABSOLUTE_PARENT_CONTROL_PATH/complete-fixed-o03-admission.json --admission-sha256 EXACT_ADMITTED_SHA256 +``` + +The outer timeout is a179s deadline with a final1s kill bound, never a budget extension. The inclusive observer begins its first-instruction timer before other imports, starts a continuous parent/descendant sampler before admission/source/runtime authentication and keeps it through all substantive closing readbacks. Runtime package/input staging, import verification, tempfile initialization, controls, complete baseline/candidate, complete independent validation, receipts, logs, success/failure cleanup checks and source/input/runtime reauthentication occur inside. Python interpreter startup before the first instruction is measured by outer GNU time, whose entire fresh observer+descendants CPU is also separately retained. `/usr/bin/time` maxRSS is an individual-process high water mark and never a simultaneous aggregate memory peak. + +The observer reports simultaneous sampled RSS for its parent and discoverable descendants,10ms interval, PID/start-time identities and missed-short-process/peak/reparenting limitations. It tracks known identities after reparenting, rejects live survivors and kills/reaps the direct child on timeout/cap/signal. No successful fixed-source branch creates an unreaped orphan: all descendant-creating fixture/coordinator branches wait/reap their children. A failed whole-operation kill can leave actual CPU gaps OPEN_NOT_ZERO and cannot qualify. No cgroup peak or exact true peak is claimed. Observer controls exercise child allocation, simultaneous parent/child/grandchild allocation, a short child, timeout+kill/reap, explicit waited child PID membership/cleanup and memory-cap kill/reap. Each fixture authenticates runtime before/after; the allocation controls do not substitute for genuine serialization. + +All initial source/bootstrap import windows before the observer sampler's first sample are exposed as sampling limitations. GNU time captures whole-process startup CPU/wall and kernel individual maxRSS. This is not an exact concurrent-RSS guarantee during unsampled windows. No source metadata is presented as target runtime admission. + +Runtime policy is explicitly `-B -I -S` for observer, coordinator, arms and fixture descendants: no system-site/.pth execution. RUNTIME-PINS-v2.json retains a conservative exact file/module allowlist from the accepted digest runtime plus named gzip/struct/ASCII/Latin1/locale files; every actual file-backed module/map must be pinned. There is no imaginary zlib extension: actual builtin zlib membership/origin and gzip provider identity must match the pinned interpreter, and actual linked libz1.3 must occur in maps. Actual _json scanner/encoder and _hashlib OpenSSL SHA256 bindings are checked. Builtin math/fcntl/select/_struct/_posixsubprocess/marshal are checked against actual sys.builtin_module_names. Any different binding fails the fixed attempt, without unmeasured discovery or patching the manifest from a lucky run. + +Before any target import all prospective runtime files and complete fresh package are authenticated. Each entry is imported by exact source location under fixed `o03_entry`, effective bindings are frozen, and its reviewed main is called once. Validator import isolation is preserved: its process imports no loader, reference or candidate. Effective fingerprints retain callable identity/code/defaults/closures, referenced callable/class globals, builtin identities, module uppercase constants and all own class slots/properties/static/class methods; they reject surviving method/function/global rebinding. Paid source-bound tempfile.gettempdir/_get_candidate_names initialization precedes sealing to prevent legitimate lazy global changes. `/tmp` is required. Mutable cache content is not frozen. Trusted local CPython/import machinery and no hostile concurrent host mutation remain explicit finite-environment assumptions; cached bytecode is not independently attested by source hashes, matching the predecessor runtime's stated assumption. + +The three input transports are copied afresh into separately owned0444 regular nlink1 files, with every input directory/root0555. Loader custody contains exactly the original three transport paths and fresh root/directory/file identities; canonical MANIFEST and anchor are separately copied into sealed package provenance. Neither original mirror modes nor matching bytes alone establish old custody. Fresh full custody checks run before/after. The consumed marker is created before substantive work; every failure is retained. Immutable staged inputs/packages and final evidence are intentionally retained, while candidate private stage cleanup is independently validated. + +The finite closing boundary has one final observer-record write and one parent readback of that record plus outer-time metadata; their known/unknown cost remains OPEN_NOT_ZERO. Parent canonical-ledger reconciliation, independent evidence adjudication, publication and historic physical gaps also remain OPEN_NOT_ZERO. No substantive serializer/control/validation/cleanup/readback is moved into this tail. P5 observer/runtime/source validation inside the operation is distinct from later independent scientific qualification. An absent/incomplete observer/time record is failure evidence requiring reconciliation, never a zero-cost attempt. + +The single source repair restores the exact whole accepted loader/consumer packet in each immutable package, including CONTROL-SPEC.json, CONSUMER-CONTROL-SPEC-v1.json and loader/CONTROL-SPEC-v1.json. Full-arm loader/reference/candidate modules are explicitly imported under the same module names the consumer uses before effective sealing; validator has no loader/reference/candidate preloads. Native env/time/timeout/interpreter/extensions/shared providers have exact pins plus passive PT_INTERP/DT_NEEDED evidence in ELF-CLOSURE-v2.json, including libc and actual loader. The trusted local loader/cache and cached-bytecode assumptions remain explicit. No ldd, native executable, target or probe ran during authorship. + +Exactly one closing parent readback command follows the admitted command: + +``` +/usr/bin/python3.12 -B -I -S ABSOLUTE_REPAIRED_ENVELOPE_PATH/parent_readback.py --admission ABSOLUTE_PARENT_CONTROL_PATH/complete-fixed-o03-admission.json --admission-sha256 EXACT_ADMITTED_SHA256 --observer-record ABSOLUTE_FRESH_OPERATION_ROOT/observer-receipt.json --outer-time ABSOLUTE_PARENT_CONTROL_PATH/outer-time.json --report ABSOLUTE_PARENT_CONTROL_PATH/parent-readback.json +``` + +The readback rejects outer individual kernel maxRSS above1GiB, outer/observer failure, missing inclusive samples or CPU-accounting closure, and any full-command/aggregate cap failure. Canonical policy charge is the full GNUtime outer reported wall plus one0.01-second textual rounding quantum; the inner observer timer is never substituted. It checks the full outer CPU includes the fresh observer/self+waited descendants within GNUtime textual precision. Parent must enter this charge into the existing canonical ledger even if later O03 adjudication refuses credit. Readback/report writing, canonical reconciliation, independent review and publication remain explicitly OPEN_NOT_ZERO. diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.json new file mode 100644 index 0000000000..ec9a61f432 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.json @@ -0,0 +1,736 @@ +{ + "assumptions": [ + "Trusted local CPython/Linux finite host; no hostile concurrent loader/host mutation.", + "Source metadata verified now; actual module origins/builtin membership/maps/callables are prospective and must pass guarded before/after checks. No target/helper/process inspection performed during source preparation.", + "Interpreter reads of cached bytecode remain an explicit trusted-host import-machinery assumption inherited from accepted predecessor; source hashes alone are not bytecode attestation.", + "Package entry imported via fixed source location then reviewed main called once; all package/input copies fresh and sealed.", + "Effective before/after fingerprints include callable identities, Python code, defaults/closures, referenced global callable/class identities, builtin authority and own class slots; mutable cache contents are outside frozen state.", + "Paid source-bound setup initializes tempfile.gettempdir and _get_candidate_names before effective seal; require /tmp. This prevents legitimate lazy global rebinding falsely rejecting first candidate/control.", + "Prospective selected callable descriptors and actual builtin membership/maps must pass the first admitted fixed operation. No runtime probe was performed." + ], + "builtin_zlib_provider": "/usr/bin/python3.12", + "callable_bindings": { + "_hashlib.openssl_sha256": { + "module": "_hashlib", + "qualname": "openssl_sha256", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + }, + "_json.make_encoder": { + "module": "_json", + "qualname": "Encoder", + "type_module": "builtins", + "type_name": "type" + }, + "_json.make_scanner": { + "module": "_json", + "qualname": "Scanner", + "type_module": "builtins", + "type_name": "type" + }, + "gzip.GzipFile": { + "module": "gzip", + "qualname": "GzipFile", + "type_module": "builtins", + "type_name": "type" + }, + "hashlib.sha256": { + "module": "_hashlib", + "qualname": "openssl_sha256", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + }, + "json.dumps": { + "module": "json", + "qualname": "dumps", + "type_module": "builtins", + "type_name": "function" + }, + "json.loads": { + "module": "json", + "qualname": "loads", + "type_module": "builtins", + "type_name": "function" + }, + "zlib.crc32": { + "module": "zlib", + "qualname": "crc32", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + }, + "zlib.decompressobj": { + "module": "zlib", + "qualname": "decompressobj", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + } + }, + "executable": "/usr/bin/python3.12", + "files": { + "/etc/python3.12/sitecustomize.py": { + "mode": 420, + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e", + "size": 155 + }, + "/usr/bin/env": { + "mode": 493, + "sha256": "886e5fa8be716b03eeda48856e0f04493f2969fc148fb7812594ffac647fa050", + "size": 48072 + }, + "/usr/bin/python3.12": { + "mode": 493, + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + "size": 8020928 + }, + "/usr/bin/time": { + "mode": 493, + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10", + "size": 27160 + }, + "/usr/bin/timeout": { + "mode": 493, + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52", + "size": 39880 + }, + "/usr/lib/locale/C.utf8/LC_CTYPE": { + "mode": 420, + "sha256": "59015993b1b671273461ef1167d7a9ad76dc090d521c91102e962217ed6b6dba", + "size": 360460 + }, + "/usr/lib/python3.12/__future__.py": { + "mode": 420, + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "size": 5218 + }, + "/usr/lib/python3.12/_collections_abc.py": { + "mode": 420, + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6", + "size": 32082 + }, + "/usr/lib/python3.12/_compression.py": { + "mode": 420, + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size": 5681 + }, + "/usr/lib/python3.12/_sitebuiltins.py": { + "mode": 420, + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size": 3128 + }, + "/usr/lib/python3.12/_weakrefset.py": { + "mode": 420, + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "size": 5893 + }, + "/usr/lib/python3.12/abc.py": { + "mode": 420, + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "size": 6538 + }, + "/usr/lib/python3.12/argparse.py": { + "mode": 420, + "sha256": "29395feb61bc376ca4ff9d44069af8d914ec2a1f25a4bd7978f6e2afef5bc07f", + "size": 101750 + }, + "/usr/lib/python3.12/ast.py": { + "mode": 420, + "sha256": "d16626aa5c054bcc45221e56f84e55051b046caf0f8be1fe4902ea71534fb735", + "size": 64260 + }, + "/usr/lib/python3.12/bisect.py": { + "mode": 420, + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999", + "size": 3423 + }, + "/usr/lib/python3.12/bz2.py": { + "mode": 420, + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size": 11847 + }, + "/usr/lib/python3.12/codecs.py": { + "mode": 420, + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785", + "size": 36870 + }, + "/usr/lib/python3.12/collections/__init__.py": { + "mode": 420, + "sha256": "0af967cd58036507b3d0fbc33b7a996c61dbb52a94b0b738c8bef12cd4cc7dd4", + "size": 52378 + }, + "/usr/lib/python3.12/collections/abc.py": { + "mode": 420, + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size": 119 + }, + "/usr/lib/python3.12/contextlib.py": { + "mode": 420, + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6", + "size": 27637 + }, + "/usr/lib/python3.12/copy.py": { + "mode": 420, + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab", + "size": 8412 + }, + "/usr/lib/python3.12/copyreg.py": { + "mode": 420, + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9", + "size": 7614 + }, + "/usr/lib/python3.12/datetime.py": { + "mode": 420, + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238", + "size": 268 + }, + "/usr/lib/python3.12/encodings/__init__.py": { + "mode": 420, + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "size": 5884 + }, + "/usr/lib/python3.12/encodings/aliases.py": { + "mode": 420, + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size": 15677 + }, + "/usr/lib/python3.12/encodings/ascii.py": { + "mode": 420, + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size": 1248 + }, + "/usr/lib/python3.12/encodings/latin_1.py": { + "mode": 420, + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size": 1264 + }, + "/usr/lib/python3.12/encodings/utf_8.py": { + "mode": 420, + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size": 1005 + }, + "/usr/lib/python3.12/enum.py": { + "mode": 420, + "sha256": "c8ead615c159598370295649eb296819ad4b40d50b200c4fec2d4269bf7af9ae", + "size": 81636 + }, + "/usr/lib/python3.12/fnmatch.py": { + "mode": 420, + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "size": 5999 + }, + "/usr/lib/python3.12/functools.py": { + "mode": 420, + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033", + "size": 38126 + }, + "/usr/lib/python3.12/genericpath.py": { + "mode": 420, + "sha256": "2b0b35d2206778af4081cf81dd9b513876e72c35a55bec941402e1fa62b1f1aa", + "size": 5572 + }, + "/usr/lib/python3.12/gettext.py": { + "mode": 420, + "sha256": "1cc6fd33bdce3bb29c0c37ec9a2f5bf15a315e9776b329247e6675c028a8af39", + "size": 21747 + }, + "/usr/lib/python3.12/gzip.py": { + "mode": 420, + "sha256": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5", + "size": 24859 + }, + "/usr/lib/python3.12/hashlib.py": { + "mode": 420, + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab", + "size": 9349 + }, + "/usr/lib/python3.12/importlib/__init__.py": { + "mode": 420, + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730", + "size": 4774 + }, + "/usr/lib/python3.12/importlib/_abc.py": { + "mode": 420, + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8", + "size": 1354 + }, + "/usr/lib/python3.12/importlib/_bootstrap.py": { + "mode": 420, + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed", + "size": 57056 + }, + "/usr/lib/python3.12/importlib/_bootstrap_external.py": { + "mode": 420, + "sha256": "97c6211750d63067712ad2cd74d50be33337f1fb1cd2c769022ced9b401edd92", + "size": 69197 + }, + "/usr/lib/python3.12/importlib/machinery.py": { + "mode": 420, + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "size": 880 + }, + "/usr/lib/python3.12/importlib/util.py": { + "mode": 420, + "sha256": "ca54e6458dbe521d591e5b8d9bb651ef929bfae946706c98470cdd569041a64f", + "size": 10840 + }, + "/usr/lib/python3.12/io.py": { + "mode": 420, + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822", + "size": 3582 + }, + "/usr/lib/python3.12/ipaddress.py": { + "mode": 420, + "sha256": "cc9831e239bd81c1480a12733bded744002d93815fd0d083c77aea348c956e67", + "size": 78294 + }, + "/usr/lib/python3.12/json/__init__.py": { + "mode": 420, + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size": 14020 + }, + "/usr/lib/python3.12/json/decoder.py": { + "mode": 420, + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size": 12473 + }, + "/usr/lib/python3.12/json/encoder.py": { + "mode": 420, + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869", + "size": 16070 + }, + "/usr/lib/python3.12/json/scanner.py": { + "mode": 420, + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size": 2425 + }, + "/usr/lib/python3.12/keyword.py": { + "mode": 420, + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b", + "size": 1073 + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76", + "size": 32112 + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe", + "size": 64368 + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3", + "size": 48952 + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7", + "size": 49256 + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907", + "size": 19432 + }, + "/usr/lib/python3.12/locale.py": { + "mode": 420, + "sha256": "d1134b7212bad37b7b81339061dc37a19a194aa183ec2cb60412cf365993b151", + "size": 78562 + }, + "/usr/lib/python3.12/lzma.py": { + "mode": 420, + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size": 13277 + }, + "/usr/lib/python3.12/ntpath.py": { + "mode": 420, + "sha256": "c4dd79bf103677daaad873952b89fc1f973425e7b250006cc35af4c164181da8", + "size": 30027 + }, + "/usr/lib/python3.12/operator.py": { + "mode": 420, + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "size": 10965 + }, + "/usr/lib/python3.12/os.py": { + "mode": 420, + "sha256": "316d1b7307fd851bded3423c9d437e0a383c725d993f0fcff2e8b749fe560b62", + "size": 39786 + }, + "/usr/lib/python3.12/pathlib.py": { + "mode": 420, + "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d", + "size": 51153 + }, + "/usr/lib/python3.12/platform.py": { + "mode": 493, + "sha256": "ed0defe8ff7c116710493ffd099b566d3de686ab1b431a3d5401056798e59341", + "size": 43331 + }, + "/usr/lib/python3.12/posixpath.py": { + "mode": 420, + "sha256": "c443d7b8afad1717e7060ce49b3e04423058de56cd4246ee6bcc1ac962eb5c2b", + "size": 17623 + }, + "/usr/lib/python3.12/random.py": { + "mode": 420, + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425", + "size": 34683 + }, + "/usr/lib/python3.12/re/__init__.py": { + "mode": 420, + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b", + "size": 16315 + }, + "/usr/lib/python3.12/re/_casefix.py": { + "mode": 420, + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "size": 5446 + }, + "/usr/lib/python3.12/re/_compiler.py": { + "mode": 420, + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "size": 26089 + }, + "/usr/lib/python3.12/re/_constants.py": { + "mode": 420, + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375", + "size": 5930 + }, + "/usr/lib/python3.12/re/_parser.py": { + "mode": 420, + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840", + "size": 41201 + }, + "/usr/lib/python3.12/reprlib.py": { + "mode": 420, + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015", + "size": 6569 + }, + "/usr/lib/python3.12/selectors.py": { + "mode": 420, + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "size": 19671 + }, + "/usr/lib/python3.12/shutil.py": { + "mode": 420, + "sha256": "819e518cb7a539d09b2526138015541b34d2646afb9c2f6ae4ffd476d6a0fcf4", + "size": 58120 + }, + "/usr/lib/python3.12/signal.py": { + "mode": 420, + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "size": 2495 + }, + "/usr/lib/python3.12/site.py": { + "mode": 420, + "sha256": "619436355cbe91c3b29681ab486ee63f5f2e0a7d6274dfae747bdb94e60bca55", + "size": 23903 + }, + "/usr/lib/python3.12/stat.py": { + "mode": 420, + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size": 5485 + }, + "/usr/lib/python3.12/struct.py": { + "mode": 420, + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size": 257 + }, + "/usr/lib/python3.12/subprocess.py": { + "mode": 420, + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9", + "size": 88725 + }, + "/usr/lib/python3.12/tempfile.py": { + "mode": 420, + "sha256": "8c8033ed1426ace79e07a6608887d2a1694d817d63d61b04c3d59339f24b4269", + "size": 37334 + }, + "/usr/lib/python3.12/threading.py": { + "mode": 420, + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b", + "size": 60123 + }, + "/usr/lib/python3.12/types.py": { + "mode": 420, + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405", + "size": 10993 + }, + "/usr/lib/python3.12/urllib/__init__.py": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + "/usr/lib/python3.12/urllib/parse.py": { + "mode": 420, + "sha256": "a67b5694763137dbac085adbf0c22821d435ec8ca22d3bd3786d2c9f4ee748d5", + "size": 45591 + }, + "/usr/lib/python3.12/warnings.py": { + "mode": 420, + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49", + "size": 21760 + }, + "/usr/lib/python3.12/weakref.py": { + "mode": 420, + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "size": 21513 + }, + "/usr/lib/python3.12/zipimport.py": { + "mode": 420, + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0", + "size": 28132 + }, + "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py": { + "mode": 420, + "sha256": "46849a60a7cc85189cf6b5ac62b3f135004862ce6a96540a81c95ef6fbc4dc3e", + "size": 6299 + }, + "/usr/lib/python3/dist-packages/apport_python_hook.py": { + "mode": 420, + "sha256": "2aac4de740babcc6038483cccc7fa71f7f06405da9b9d102aafe8ac55f509c4b", + "size": 8695 + }, + "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py": { + "mode": 420, + "sha256": "c38b82e5f241e83edbbe9bcfdcb8747f11071b32fbc8b7c950e38260a0059edb", + "size": 122 + }, + "/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache": { + "mode": 420, + "sha256": "52c227df9d53248238602c1ddaccd2c8ddc4cc6a61aa45d7c425af590b8806a5", + "size": 27028 + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "mode": 493, + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da", + "size": 236616 + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "mode": 420, + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1", + "size": 78944 + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "mode": 493, + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf", + "size": 2129424 + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "mode": 420, + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a", + "size": 5309400 + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "mode": 420, + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d", + "size": 186624 + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "mode": 420, + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d", + "size": 202904 + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "mode": 420, + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0", + "size": 952616 + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "mode": 420, + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242", + "size": 113000 + } + }, + "linked_libz": "/usr/lib/x86_64-linux-gnu/libz.so.1.3", + "mapped_files": [ + "/usr/bin/python3.12", + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4", + "/usr/lib/x86_64-linux-gnu/libc.so.6", + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3", + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1", + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5", + "/usr/lib/x86_64-linux-gnu/libm.so.6", + "/usr/lib/x86_64-linux-gnu/libz.so.1.3", + "/usr/lib/locale/C.utf8/LC_CTYPE", + "/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache" + ], + "module_paths": { + "__future__": "/usr/lib/python3.12/__future__.py", + "_bz2": "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so", + "_collections_abc": "/usr/lib/python3.12/_collections_abc.py", + "_compression": "/usr/lib/python3.12/_compression.py", + "_distutils_hack": "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py", + "_frozen_importlib": "/usr/lib/python3.12/importlib/_bootstrap.py", + "_frozen_importlib_external": "/usr/lib/python3.12/importlib/_bootstrap_external.py", + "_hashlib": "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so", + "_json": "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so", + "_lzma": "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so", + "_sitebuiltins": "/usr/lib/python3.12/_sitebuiltins.py", + "_weakrefset": "/usr/lib/python3.12/_weakrefset.py", + "abc": "/usr/lib/python3.12/abc.py", + "apport_python_hook": "/usr/lib/python3/dist-packages/apport_python_hook.py", + "argparse": "/usr/lib/python3.12/argparse.py", + "ast": "/usr/lib/python3.12/ast.py", + "bisect": "/usr/lib/python3.12/bisect.py", + "bz2": "/usr/lib/python3.12/bz2.py", + "codecs": "/usr/lib/python3.12/codecs.py", + "collections": "/usr/lib/python3.12/collections/__init__.py", + "collections.abc": "/usr/lib/python3.12/collections/abc.py", + "contextlib": "/usr/lib/python3.12/contextlib.py", + "copy": "/usr/lib/python3.12/copy.py", + "copyreg": "/usr/lib/python3.12/copyreg.py", + "datetime": "/usr/lib/python3.12/datetime.py", + "encodings": "/usr/lib/python3.12/encodings/__init__.py", + "encodings.aliases": "/usr/lib/python3.12/encodings/aliases.py", + "encodings.ascii": "/usr/lib/python3.12/encodings/ascii.py", + "encodings.latin_1": "/usr/lib/python3.12/encodings/latin_1.py", + "encodings.utf_8": "/usr/lib/python3.12/encodings/utf_8.py", + "enum": "/usr/lib/python3.12/enum.py", + "fnmatch": "/usr/lib/python3.12/fnmatch.py", + "functools": "/usr/lib/python3.12/functools.py", + "genericpath": "/usr/lib/python3.12/genericpath.py", + "gettext": "/usr/lib/python3.12/gettext.py", + "gzip": "/usr/lib/python3.12/gzip.py", + "hashlib": "/usr/lib/python3.12/hashlib.py", + "importlib": "/usr/lib/python3.12/importlib/__init__.py", + "importlib._abc": "/usr/lib/python3.12/importlib/_abc.py", + "importlib._bootstrap": "/usr/lib/python3.12/importlib/_bootstrap.py", + "importlib._bootstrap_external": "/usr/lib/python3.12/importlib/_bootstrap_external.py", + "importlib.machinery": "/usr/lib/python3.12/importlib/machinery.py", + "importlib.util": "/usr/lib/python3.12/importlib/util.py", + "io": "/usr/lib/python3.12/io.py", + "ipaddress": "/usr/lib/python3.12/ipaddress.py", + "json": "/usr/lib/python3.12/json/__init__.py", + "json.decoder": "/usr/lib/python3.12/json/decoder.py", + "json.encoder": "/usr/lib/python3.12/json/encoder.py", + "json.scanner": "/usr/lib/python3.12/json/scanner.py", + "keyword": "/usr/lib/python3.12/keyword.py", + "locale": "/usr/lib/python3.12/locale.py", + "lzma": "/usr/lib/python3.12/lzma.py", + "mpl_toolkits": "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py", + "ntpath": "/usr/lib/python3.12/ntpath.py", + "operator": "/usr/lib/python3.12/operator.py", + "os": "/usr/lib/python3.12/os.py", + "os.path": "/usr/lib/python3.12/posixpath.py", + "pathlib": "/usr/lib/python3.12/pathlib.py", + "platform": "/usr/lib/python3.12/platform.py", + "posixpath": "/usr/lib/python3.12/posixpath.py", + "random": "/usr/lib/python3.12/random.py", + "re": "/usr/lib/python3.12/re/__init__.py", + "re._casefix": "/usr/lib/python3.12/re/_casefix.py", + "re._compiler": "/usr/lib/python3.12/re/_compiler.py", + "re._constants": "/usr/lib/python3.12/re/_constants.py", + "re._parser": "/usr/lib/python3.12/re/_parser.py", + "reprlib": "/usr/lib/python3.12/reprlib.py", + "resource": "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so", + "selectors": "/usr/lib/python3.12/selectors.py", + "shutil": "/usr/lib/python3.12/shutil.py", + "signal": "/usr/lib/python3.12/signal.py", + "site": "/usr/lib/python3.12/site.py", + "sitecustomize": "/etc/python3.12/sitecustomize.py", + "stat": "/usr/lib/python3.12/stat.py", + "struct": "/usr/lib/python3.12/struct.py", + "subprocess": "/usr/lib/python3.12/subprocess.py", + "tempfile": "/usr/lib/python3.12/tempfile.py", + "threading": "/usr/lib/python3.12/threading.py", + "types": "/usr/lib/python3.12/types.py", + "urllib": "/usr/lib/python3.12/urllib/__init__.py", + "urllib.parse": "/usr/lib/python3.12/urllib/parse.py", + "warnings": "/usr/lib/python3.12/warnings.py", + "weakref": "/usr/lib/python3.12/weakref.py", + "zipimport": "/usr/lib/python3.12/zipimport.py" + }, + "package_modules": { + "bootstrap": "envelope/bootstrap.py", + "bounded_serialization": "consumer/bounded_serialization.py", + "custody": "envelope/custody.py", + "effective": "envelope/effective.py", + "frozen_h25_inputs": "loader/frozen_h25_inputs.py", + "frozen_input_controls": "loader/frozen_input_controls.py", + "full_consumer": "consumer/full_consumer.py", + "loader_controls": "envelope/loader_controls.py", + "observer": "envelope/observer.py", + "observer_controls": "envelope/observer_controls.py", + "observer_fixture": "envelope/observer_fixture.py", + "parent_readback": "envelope/parent_readback.py", + "reference": "consumer/reference.py", + "run_controls": "consumer/run_controls.py", + "sequence_worker": "envelope/sequence_worker.py", + "serialization_controls": "consumer/serialization_controls.py", + "validate_outputs": "consumer/validate_outputs.py", + "worker": "envelope/worker.py" + }, + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/stages/inventory-v1/RUNTIME-PINS.json", + "sha256": "ad2655b40ae2340048526a02d9a4215341112ef27f565c32a7ea5a87e80a0061" + }, + "preload_modules": [ + "argparse", + "copy", + "contextlib", + "gzip", + "hashlib", + "importlib.util", + "json", + "json.encoder", + "math", + "os", + "pathlib", + "stat", + "sys", + "time", + "types", + "tempfile", + "shutil", + "threading", + "resource", + "fcntl", + "subprocess", + "marshal", + "_json", + "_hashlib" + ], + "python_version": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "remaining_guarded_acquisition": "No unmeasured discovery probe. First admitted observer-controls attempt performs exact required builtin/origin/map/selected-binding checks and fails closed on mismatch; never amend from success/failure without new independent review and consumed-operation disposition.", + "required_builtin_modules": [ + "zlib", + "math", + "fcntl", + "select", + "_struct", + "_posixsubprocess", + "marshal" + ], + "schema": "o03-prospective-runtime-pins-v2", + "site_policy": "-B -I -S for every process; actual flags.no_site=1 required; site/.pth not executed.", + "source_effective_preload_policy": "FIXED-SEQUENCE-v2.json per-job effective_package_preloads: loader in both arms; bounded_serialization only candidate; validator none; same exact sys.modules names used by consumer run.", + "source_repair_count": 1, + "static_ELF_closure_sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "status": "SOURCE_METADATA_ONLY_NOT_RUNTIME_ADMISSION", + "successful_CPU_tree": "Every fixed source child either has no children or explicitly waits/reaps them. No orphan fixture; membership control waits/reaps. Failed whole-operation kills can leave CPU gaps OPEN_NOT_ZERO.", + "wrapper_binaries": { + "/usr/bin/env": { + "mode": 493, + "sha256": "886e5fa8be716b03eeda48856e0f04493f2969fc148fb7812594ffac647fa050", + "size": 48072 + }, + "/usr/bin/time": { + "mode": 493, + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10", + "size": 27160 + }, + "/usr/bin/timeout": { + "mode": 493, + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52", + "size": 39880 + } + } +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.sha256 b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.sha256 new file mode 100644 index 0000000000..fa02fd12e1 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/RUNTIME-PINS-v2.sha256 @@ -0,0 +1 @@ +4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/SOURCE-READINESS-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/SOURCE-READINESS-v2.json new file mode 100644 index 0000000000..9a20e9ace0 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/SOURCE-READINESS-v2.json @@ -0,0 +1,116 @@ +{ + "I3_independently_accepted": false, + "files": { + "ADMISSION-TEMPLATE-v2.json": { + "mode": 292, + "sha256": "a42c3e6ade467b142647e2e3aac2ce53e67de1ba2309fcc15ec9a8d98c440f88", + "size": 25423 + }, + "ELF-CLOSURE-v2.json": { + "mode": 292, + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "size": 8733 + }, + "FIXED-SEQUENCE-v2.json": { + "mode": 292, + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf", + "size": 5379 + }, + "OPERATION-BILL-v2.json": { + "mode": 292, + "sha256": "49f9ae04f02cf01f709cda31628a4223aebe206e0778ab0e91eee176ceed96a1", + "size": 4762 + }, + "PASSIVE-CHECKS-v2.json": { + "mode": 292, + "sha256": "b7bb642363b16034690ebbc16f6546d4e15e3cac038c4698e743d5427c52f6e0", + "size": 2440 + }, + "README-v2.md": { + "mode": 292, + "sha256": "46818370bf55026df7b05b2eb439a77d6ce5dba3d74fa97844a651a51a2a9a93", + "size": 9784 + }, + "RUNTIME-PINS-v2.json": { + "mode": 292, + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "size": 28663 + }, + "RUNTIME-PINS-v2.sha256": { + "mode": 292, + "sha256": "3bdd33b13783a402ecd4b3d48fbba117b7b72275317d3b23537ca972e4909d8e", + "size": 65 + }, + "SOURCE-REPAIR-v2.json": { + "mode": 292, + "sha256": "35bc801f6fb32857ad8e3c5ccd9eea2d0540f8aa470f0d8d8e194a1522f2f589", + "size": 854 + }, + "bootstrap.py": { + "mode": 292, + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "custody.py": { + "mode": 292, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "effective.py": { + "mode": 292, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "loader_controls.py": { + "mode": 292, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "observer.py": { + "mode": 292, + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "observer_controls.py": { + "mode": 292, + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "observer_fixture.py": { + "mode": 292, + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "parent_readback.py": { + "mode": 292, + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "sequence_worker.py": { + "mode": 292, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "worker.py": { + "mode": 292, + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + } + }, + "original_packet_preserved": true, + "parent_execution_admitted": false, + "remaining": [ + "Independent repaired I3 exact-source and finite-boundary acceptance", + "Parent source-pinned exact admission/canonical-ledger refresh+single fixed command approval", + "Actual guarded first control/runtime/input/cap/receipt/cleanup predicates remain unexecuted and may stop fixed attempt", + "One parentreadback fullouterwall/maxRSS; canonical charging+independent resource/O03 adjudication+publication remain open" + ], + "runtime_manifest": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "runtime_sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "schema": "o03-I3-source-readiness-v2", + "source_execution_count": 0, + "source_files_mode_octal": "0444", + "source_repair_count": 1, + "status": "ONE_REPAIR_COMPLETE_SOURCE_ONLY_PENDING_INDEPENDENT_REVIEW", + "tests_controls_benchmarks": 0 +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/SOURCE-REPAIR-v2.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/SOURCE-REPAIR-v2.json new file mode 100644 index 0000000000..84eccbc72c --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/SOURCE-REPAIR-v2.json @@ -0,0 +1,15 @@ +{ + "I1_I2_sources_edited": false, + "count": 1, + "fixed": [ + "complete exact accepted I1/I2 package and control spec stage", + "actual fullarm loader/candidate effective-before preloads under same consumer module names", + "waited membership cleanup control avoids unreaped orphan CPU loss", + "exact native wrapper/provider static closure and fullouterwall/maxRSS parent readback" + ], + "formal_rejection_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-REVIEW-v1.json", + "formal_rejection_sha256": "33113ecfebd19c41caa370f6da3591d38febe51e97a62c0c11a310921d4c0ebd", + "runtime_work_performed": false, + "schema": "o03-single-integrated-source-repair-v2", + "v1_original_packet": "../../versions/v1-rejected/" +} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/bootstrap.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/bootstrap.py new file mode 100644 index 0000000000..7b3e4275ce --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/bootstrap.py @@ -0,0 +1,156 @@ +"""Run a fixed target in the same interpreter as effective runtime checks. + +This module is entered only from the inclusive observer. All imports and checks +here are inside that boundary. Runtime manifests are independently frozen, never +learned from a successful target or amended after a failure. +""" +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import gzip +import hashlib +import importlib +import json +import os +from effective import capture, unchanged +import zlib +from custody import check_snapshot, need, pin, read_json, safe, same, write_json + + +def mappings(): + paths = set() + for line in Path('/proc/self/maps').read_text().splitlines(): + row = line.split(maxsplit=5) + if len(row) == 6 and row[5].startswith('/'): + need(not row[5].endswith(' (deleted)'), 'deleted runtime mapping') + paths.add(str(Path(row[5]).resolve())) + return paths + + +def callable_bindings(): + import _json + import _hashlib + selected = {'gzip.GzipFile': gzip.GzipFile, 'zlib.decompressobj': zlib.decompressobj, + 'zlib.crc32': zlib.crc32, 'json.loads': json.loads, 'json.dumps': json.dumps, + '_json.make_scanner': _json.make_scanner, '_json.make_encoder': _json.make_encoder, + 'hashlib.sha256': hashlib.sha256, '_hashlib.openssl_sha256': _hashlib.openssl_sha256} + names = {name: {'module': getattr(obj, '__module__', None), + 'qualname': getattr(obj, '__qualname__', getattr(obj, '__name__', None)), + 'type_module': type(obj).__module__, 'type_name': type(obj).__name__} + for name, obj in selected.items()} + return selected, names + + +def closure(runtime, package, entry, main_path=None): + # Source-bound lazy initialization is paid setup before effective sealing. + # tempfile's first gettempdir/name-sequence otherwise legitimately rebinds + # globals during the first target mkdtemp and creates false drift. + import tempfile + need(tempfile.gettempdir() == '/tmp', 'unexpected effective temp directory') + tempfile._get_candidate_names() + need(all(name in sys.builtin_module_names for name in runtime['required_builtin_modules']), + 'required actual builtin provider missing') + need(Path(sys.executable).resolve() == Path(runtime['executable']), 'interpreter mismatch') + need(sys.version == runtime['python_version'], 'interpreter version mismatch') + need(sys.flags.isolated == 1 and sys.flags.dont_write_bytecode == 1 and sys.flags.no_site == 1, 'isolated -B -S required') + need(zlib.__spec__.origin == 'built-in' and 'zlib' in sys.builtin_module_names, + 'actual builtin zlib provider required; no fictional extension') + need(gzip.zlib is zlib, 'gzip provider differs') + need(runtime['builtin_zlib_provider'] == runtime['executable'], 'builtin provider pin differs') + for filename, expected in sorted(runtime['files'].items()): + same(Path(filename), expected) + observed = {} + for name, module in sorted(tuple(sys.modules.items())): + if module is None: + continue + filename = getattr(module, '__file__', None) + if filename is None: + spec = getattr(module, '__spec__', None) + origin = getattr(spec, 'origin', None) + need(origin in ('built-in', 'frozen') and + (origin == 'frozen' or name in sys.builtin_module_names), 'unsealed no-file module: ' + name) + continue + actual = str(Path(filename).resolve()) + if name == '__main__': + expected = str(Path(main_path or __file__).resolve()) + elif name == 'o03_entry': + expected = str(entry) + elif actual.startswith(str(package) + '/'): + relative = str(Path(actual).relative_to(package)) + need(relative in runtime['package_modules'].values(), 'undeclared package module: ' + name) + need(name in runtime['package_modules'], 'unsealed package module alias: ' + name) + expected = str(package / runtime['package_modules'][name]) + else: + expected = runtime['module_paths'].get(name) + need(actual == expected, 'unexpected runtime module origin: ' + name + '=' + actual) + observed[name] = actual + actual_maps = mappings() + need(actual_maps <= set(runtime['mapped_files']), 'unsealed mapped files: ' + repr(sorted(actual_maps - set(runtime['mapped_files'])))) + need(runtime['linked_libz'] in actual_maps, 'actual linked libz missing') + objects, descriptors = callable_bindings() + need(descriptors == runtime['callable_bindings'], 'selected implementation binding mismatch') + return {'module_origins': observed, 'mapped_files': sorted(actual_maps), + 'builtin_zlib_provider': runtime['builtin_zlib_provider'], 'linked_libz': runtime['linked_libz'], + 'selected_callable_bindings': descriptors}, objects + + +def main(): + need(len(sys.argv) == 3, 'bootstrap requires request and exact request digest') + request = read_json(Path(sys.argv[1]), sys.argv[2]) + runtime = read_json(Path(request['runtime_manifest']), request['runtime_sha256']) + package = safe(Path(request['package_custody']['root'])) + entry = safe(package / request['entry']) + need(request['entry'] in request['package_custody']['files'], 'unsealed target entry') + check_snapshot(request['package_custody']) + report = {'schema': 'o03-effective-runtime-v1', 'status': 'STARTED', 'errors': []} + before_objects = None + effective_before = None + try: + # Freeze imports used by all execution branches, including conditional helpers. + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + for name in runtime['preload_modules']: + importlib.import_module(name) + # Import the entry without running its guarded main, then freeze actual + # effective package bindings and execute exactly its reviewed main(). + sys.path.insert(0, str(entry.parent)) + sys.path.insert(1, str(package / 'loader')) + spec = importlib.util.spec_from_file_location('o03_entry', entry) + entry_module = importlib.util.module_from_spec(spec) + sys.modules['o03_entry'] = entry_module + spec.loader.exec_module(entry_module) + # Source-fixed branch closure is imported before effective sealing. + # Validator has no such preload and retains independent imports. + for module_name in request['effective_package_preloads']: + need(module_name in runtime['package_modules'], 'undeclared effective package preload') + importlib.import_module(module_name) + report['before'], before_objects = closure(runtime, package, entry) + effective_before = capture(dict(sys.modules)) + report['effective_before'] = effective_before + sys.argv = [str(entry), *request['argv']] + entry_module.main() + report['target_returned'] = True + except SystemExit as error: + report['target_exit'] = error.code + if error.code not in (0, None): + report['errors'].append({'type': 'SystemExit', 'message': str(error.code)}) + except BaseException as error: + report['errors'].append({'type': type(error).__name__, 'message': str(error)}) + finally: + try: + report['after'], after_objects = closure(runtime, package, entry) + report['effective_after'] = capture(dict(sys.modules)) + need(effective_before is not None, 'effective before seal absent') + unchanged(effective_before, report['effective_after']) + need(before_objects is not None and all(after_objects[k] is v for k, v in before_objects.items()), + 'callable rebound during target') + check_snapshot(request['package_custody']) + except BaseException as error: + report['errors'].append({'check': 'after', 'type': type(error).__name__, 'message': str(error)}) + report['status'] = 'PASS' if not report['errors'] else 'STOP' + write_json(Path(request['runtime_report']), report) + need(report['status'] == 'PASS', 'effective runtime/target failure') + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/custody.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/custody.py new file mode 100644 index 0000000000..c7aaad3522 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/custody.py @@ -0,0 +1,131 @@ +"""Immutable copies and fresh identity authentication. No target imports.""" +import hashlib +import json +import os +from pathlib import Path +import stat + +CHUNK = 65536 + + +def need(ok, message): + if not ok: + raise RuntimeError(message) + + +def safe(path): + path = Path(path) + need(path.is_absolute() and path.resolve() == path, 'noncanonical/symlink path: ' + str(path)) + for ancestor in (path, *path.parents): + need(not ancestor.is_symlink(), 'symlink ancestor: ' + str(ancestor)) + return path + + +def fields(info, directory=False): + result = {key: getattr(info, 'st_' + key) for key in + ('dev', 'ino', 'uid', 'gid', 'nlink', 'mtime_ns', 'ctime_ns')} + result['mode'] = stat.S_IMODE(info.st_mode) + if not directory: + result['size'] = info.st_size + return result + + +def pin(path, immutable=False): + path = safe(path) + before = path.lstat() + need(stat.S_ISREG(before.st_mode) and before.st_nlink == 1, 'regular unique-link file required') + if immutable: + need(stat.S_IMODE(before.st_mode) == 0o444, 'immutable0444 required') + fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK) + with os.fdopen(fd, 'rb', buffering=0) as stream: + opened = os.fstat(stream.fileno()) + h, count = hashlib.sha256(), 0 + while True: + data = stream.read(CHUNK) + if not data: + break + h.update(data) + count += len(data) + after = os.fstat(stream.fileno()) + need(fields(before) == fields(opened) == fields(after) == fields(path.lstat()), 'identity drift') + need(count == after.st_size, 'size drift') + return dict(fields(after), sha256=h.hexdigest()) + + +def same(path, expected, immutable=False): + actual = pin(path, immutable) + need(all(actual.get(k) == v for k, v in expected.items()), 'pin mismatch: ' + str(path)) + return actual + + +def read_json(path, expected_sha=None): + path = safe(path) + info = pin(path) + need(info['size'] <= 4 * 1024 * 1024, 'metadata cap') + if expected_sha is not None: + need(info['sha256'] == expected_sha, 'metadata anchor mismatch') + raw = path.read_bytes() + need(hashlib.sha256(raw).hexdigest() == info['sha256'], 'metadata read drift') + return json.loads(raw) + + +def write_json(path, value): + raw = (json.dumps(value, sort_keys=True, indent=2, allow_nan=False) + '\n').encode() + need(len(raw) <= 4 * 1024 * 1024, 'metadata cap') + with Path(path).open('xb') as stream: + stream.write(raw) + stream.flush() + os.fsync(stream.fileno()) + + +def stage(root, sources): + """sources maps safe relative destination to {path,sha256,size,mode optional}.""" + root = safe(root) + root.mkdir(mode=0o700) + for name, spec in sorted(sources.items()): + relative = Path(name) + need(not relative.is_absolute() and '..' not in relative.parts, 'unsafe relative copy') + source = safe(Path(spec['path'])) + before = same(source, {k: v for k, v in spec.items() if k != 'path'}) + destination = root / relative + destination.parent.mkdir(parents=True, exist_ok=True, mode=0o700) + with source.open('rb') as src, destination.open('xb') as dst: + while True: + data = src.read(CHUNK) + if not data: + break + dst.write(data) + dst.flush() + os.fsync(dst.fileno()) + destination.chmod(0o444) + copied = pin(destination, True) + need(copied['sha256'] == before['sha256'] and copied['size'] == before['size'], 'copy mismatch') + need((copied['dev'], copied['ino']) != (before['dev'], before['ino']), 'copy aliases source') + same(source, before) + directories = sorted((p for p in root.rglob('*') if p.is_dir()), key=lambda p: len(p.parts), reverse=True) + for directory in directories: + directory.chmod(0o555) + root.chmod(0o555) + return snapshot(root) + + +def snapshot(root): + root = safe(root) + need(root.is_dir() and stat.S_IMODE(root.stat().st_mode) == 0o555, 'root0555 required') + files, directories = {}, {} + for path in sorted(root.rglob('*')): + safe(path) + if path.is_dir(): + need(stat.S_IMODE(path.stat().st_mode) == 0o555, 'directory0555 required') + directories[str(path.relative_to(root))] = fields(path.stat(), True) + else: + files[str(path.relative_to(root))] = pin(path, True) + identities = [(v['dev'], v['ino']) for v in files.values()] + need(len(identities) == len(set(identities)), 'aliased staged files') + return {'schema': 'h25-input-custody-v1', 'root': str(root), + 'root_identity': fields(root.stat(), True), 'directories': directories, 'files': files} + + +def check_snapshot(custody): + need(snapshot(Path(custody['root'])) == custody, 'fresh custody mismatch') + return {'files': len(custody['files']), 'fresh_full_read': True} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/effective.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/effective.py new file mode 100644 index 0000000000..22b85b723d --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/effective.py @@ -0,0 +1,86 @@ +"""Source-derived callable/class/default/global binding fingerprints. + +Only ordinary interpreter metadata is inspected; descriptors and target functions +are never invoked. Mutable cache contents are not frozen. Binding identities, +Python code/defaults/closures, builtin authority and all class methods are. +""" +import builtins +import hashlib +import json +import marshal +from pathlib import Path +import types +from custody import need + + +def value(obj, depth=0): + if type(obj) in (str, int, bool, float, bytes, type(None)): + return [type(obj).__name__, repr(obj)] + if depth < 8 and type(obj) in (tuple, list): + return [type(obj).__name__, [value(x, depth + 1) for x in obj]] + if depth < 8 and type(obj) is dict: + return ['dict', sorted((repr(k), value(v, depth + 1)) for k, v in obj.items())] + return ['identity', type(obj).__module__, type(obj).__qualname__, id(obj)] + + +def fingerprint(module): + seen, rows = set(), [] + def visit(label, obj, depth=0): + if id(obj) in seen or depth > 16: + return + seen.add(id(obj)) + if type(obj) is types.FunctionType: + code = obj.__code__ + names = set(code.co_names) + global_bindings = [] + for name in sorted(names): + if name in obj.__globals__: + bound = obj.__globals__[name] + global_bindings.append((name, id(bound), type(bound).__module__, type(bound).__qualname__)) + if isinstance(bound, (types.FunctionType, type)): + visit(label + '.global.' + name, bound, depth + 1) + elif hasattr(builtins, name): + bound = vars(builtins)[name] + global_bindings.append(('builtins.' + name, id(bound), type(bound).__name__)) + rows.append((label, 'function', id(obj), hashlib.sha256(marshal.dumps(code)).hexdigest(), + value(obj.__defaults__), value(obj.__kwdefaults__), + [value(cell.cell_contents) for cell in (obj.__closure__ or ())], global_bindings, + id(obj.__builtins__))) + wrapped = vars(obj).get('__wrapped__') + if wrapped is not None: + visit(label + '.__wrapped__', wrapped, depth + 1) + elif isinstance(obj, type): + rows.append((label, 'class', id(obj), [(b.__module__, b.__qualname__, id(b)) for b in obj.__bases__])) + for name, bound in sorted(vars(obj).items()): + if isinstance(bound, (staticmethod, classmethod)): + bound = bound.__func__ + if isinstance(bound, property): + for suffix in ('fget', 'fset', 'fdel'): + function = getattr(bound, suffix) + if function is not None: + visit(label + '.' + name + '.' + suffix, function, depth + 1) + elif isinstance(bound, (types.FunctionType, type, types.BuiltinFunctionType, + types.MethodDescriptorType, types.WrapperDescriptorType)): + visit(label + '.' + name, bound, depth + 1) + elif isinstance(obj, (types.BuiltinFunctionType, types.MethodDescriptorType, types.WrapperDescriptorType)): + rows.append((label, 'native', id(obj), getattr(obj, '__module__', None), getattr(obj, '__qualname__', None))) + for name, obj in sorted(vars(module).items()): + if isinstance(obj, (types.FunctionType, type, types.BuiltinFunctionType)): + visit(name, obj) + elif name.isupper() and type(obj) in (tuple, str, int, bool, dict, list): + rows.append((name, 'constant', value(obj))) + raw = json.dumps(rows, sort_keys=True, separators=(',', ':')).encode() + return {'sha256': hashlib.sha256(raw).hexdigest(), 'binding_rows': len(rows)} + + +def capture(modules): + result = {} + for name, module in sorted(modules.items()): + if module is not None and getattr(module, '__file__', None): + result[name] = fingerprint(module) + return result + + +def unchanged(before, after): + for name, expected in before.items(): + need(after.get(name) == expected, 'effective callable/class/default/global binding drift: ' + name) diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/loader_controls.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/loader_controls.py new file mode 100644 index 0000000000..0e09204abc --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/loader_controls.py @@ -0,0 +1,23 @@ +"""Receipt adapter for the independently frozen39 loader controls.""" +import argparse +from pathlib import Path +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +sys.path.insert(1, str(Path(__file__).resolve().parent.parent / 'loader')) +from custody import need, write_json +import frozen_input_controls + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--output-root', required=True) + parser.add_argument('--receipt', required=True) + args = parser.parse_args() + Path(args.output_root).mkdir(mode=0o700) + result = frozen_input_controls.run_controls() + need(result['status'] == 'LOADER_CONTROLS_PASS' and result['count'] == 39, 'loader controls mismatch') + write_json(Path(args.receipt), result) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer.py new file mode 100644 index 0000000000..46fe7cda25 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer.py @@ -0,0 +1,275 @@ +"""Inclusive observer/serialized admission. Final one-write tail remains OPEN_NOT_ZERO. + +The first Python instruction starts the operation timer before other imports, +source authentication, staging, controls or target imports. Interpreter startup +before this instruction is additionally visible to an enclosing canonical guard; +never report it as zero or as a measured portion of this timer. +""" +import time +START = time.monotonic() +import resource +SELF_START = resource.getrusage(resource.RUSAGE_SELF) +CHILD_START = resource.getrusage(resource.RUSAGE_CHILDREN) +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import signal +import subprocess +import sys +import threading +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, pin, read_json, safe, same, write_json + +RSS_CAP = 1073741824 +TIME_CAP = 180.0 +INTERVAL = 0.01 +LOG_CAP = 4 * 1024 * 1024 + + +def process_table(): + result = {} + for path in Path('/proc').iterdir(): + if not path.name.isdecimal(): + continue + try: + raw = (path / 'stat').read_text() + row = raw[raw.rfind(')') + 2:].split() + result[int(path.name)] = {'state': row[0], 'ppid': int(row[1]), 'pgrp': int(row[2]), + 'start_ticks': int(row[19]), 'rss_bytes': max(0, int(row[21])) * os.sysconf('SC_PAGE_SIZE')} + except (OSError, ValueError, IndexError): + continue + return result + + +def sample_tree(root, known): + table = process_table() + members = {root} if root in table else set() + changed = True + while changed: + added = {pid for pid, info in table.items() if info['ppid'] in members} - members + changed = bool(added) + members |= added + # Keep previously seen identities even after reparenting; PID reuse is rejected. + for pid, start in tuple(known.items()): + if pid in table and table[pid]['start_ticks'] == start: + members.add(pid) + for pid in members: + known[pid] = table[pid]['start_ticks'] + return sum(table[pid]['rss_bytes'] for pid in members), table, members + + +def terminate(process, known): + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + table = process_table() + for pid, start in known.items(): + if pid != os.getpid() and pid in table and table[pid]['start_ticks'] == start: + try: + os.kill(pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + + +def observe(command, cwd, folder, deadline, rss_cap=RSS_CAP, interval=INTERVAL): + """Observe current parent plus all discoverable descendants, including cleanup.""" + folder = Path(folder) + folder.mkdir(mode=0o700) + known, peak, samples, termination = {}, 0, 0, None + start = time.monotonic() + out_path, err_path = folder / 'stdout.txt', folder / 'stderr.txt' + child = None + old_handlers = {} + signals = [] + def interrupted(signum, frame): + signals.append(signum) + for signum in (signal.SIGINT, signal.SIGTERM): + old_handlers[signum] = signal.signal(signum, interrupted) + try: + with out_path.open('xb') as out, err_path.open('xb') as err: + child = subprocess.Popen(command, cwd=cwd, stdin=subprocess.DEVNULL, stdout=out, + stderr=err, start_new_session=True, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C.UTF-8', 'TZ': 'UTC', + 'PYTHONDONTWRITEBYTECODE': '1'}) + while True: + rss, table, members = sample_tree(os.getpid(), known) + peak, samples = max(peak, rss), samples + 1 + if rss > rss_cap: + termination = 'sampled_tree_rss_cap' + elif time.monotonic() > deadline: + termination = 'wall_or_aggregate_cap' + elif signals: + termination = 'signal_' + str(signals[0]) + elif max(out_path.stat().st_size, err_path.stat().st_size) > LOG_CAP: + termination = 'retained_log_cap' + code = child.poll() + if termination is not None: + terminate(child, known) + code = child.returncode + break + if code is not None: + break + time.sleep(interval) + # All known living descendants make this command fail, even if main returned0. + rss, table, members = sample_tree(os.getpid(), known) + peak, samples = max(peak, rss), samples + 1 + survivors = sorted(pid for pid in members if pid != os.getpid() and pid in table and table[pid]['state'] != 'Z') + if survivors: + termination = termination or 'surviving_descendants' + terminate(child, known) + logs = {'stdout': pin(out_path), 'stderr': pin(err_path)} + need(all(v['size'] <= LOG_CAP for v in logs.values()), 'log cap on closing readback') + return {'command': command, 'exit': code, 'termination': termination, + 'wall_seconds': time.monotonic() - start, 'sampled_simultaneous_tree_rss_bytes': peak, + 'samples': samples, 'interval_seconds': interval, + 'tracked_identities': {str(k): v for k, v in sorted(known.items())}, + 'survivors_before_cleanup': survivors, 'logs': logs, + 'limits': {'rss_bytes': rss_cap, 'deadline_monotonic': deadline}} + finally: + if child is not None and child.poll() is None: + terminate(child, known) + for signum, handler in old_handlers.items(): + signal.signal(signum, handler) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--admission', required=True) + parser.add_argument('--admission-sha256', required=True) + args = parser.parse_args() + # Observe parent authentication and closing checks too; target work is also + # continuously sampled by this thread, independently of the foreground guard. + stop_sampling, inclusive_known = threading.Event(), {} + inclusive = {'peak': 0, 'samples': 0, 'errors': []} + def sampler(): + while not stop_sampling.is_set(): + try: + rss, _, _ = sample_tree(os.getpid(), inclusive_known) + inclusive['peak'] = max(inclusive['peak'], rss) + inclusive['samples'] += 1 + except BaseException as error: + inclusive['errors'].append(type(error).__name__ + ': ' + str(error)) + stop_sampling.wait(INTERVAL) + sampling_thread = threading.Thread(target=sampler, name='inclusive-rss-observer', daemon=True) + sampling_thread.start() + admission = read_json(Path(args.admission), args.admission_sha256) + need(admission['schema'] == 'o03-envelope-admission-v1', 'admission schema') + need(admission['independent_source_accepted'] is True and admission['parent_execution_admitted'] is True, + 'explicit independent source and parent admission required') + need(admission['maximum_command_seconds'] == TIME_CAP and admission['sampled_group_cap_bytes'] == RSS_CAP, + 'caps differ') + ledger = admission['canonical_ledger'] + need(ledger['cap_seconds'] == 2400 and 0 <= ledger['spent_seconds'] < 2400, 'canonical budget invalid') + lock_path = safe(Path(ledger['lock_path'])) + with lock_path.open('a+b') as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + for filename, expected in ledger['fresh_files'].items(): + same(Path(filename), expected) + # Consume before source checks/staging so failures cannot reroll this fixed operation. + consumed = Path(admission['consumed_marker']) + with consumed.open('xb') as marker: + marker.write((args.admission_sha256 + '\n').encode('ascii')) + marker.flush() + os.fsync(marker.fileno()) + folder = safe(Path(admission['operation_root'])) + folder.mkdir(mode=0o700) + record = {'schema': 'o03-inclusive-observer-v1', 'status': 'STARTED', + 'admission_sha256': args.admission_sha256, 'errors': [], + 'outside_tail': {'final_observer_record_writes': 1, 'parent_readbacks': 1, + 'cost': 'OPEN_NOT_ZERO', 'publication': 'OPEN_NOT_ZERO'}, + 'measurement': {'sampled_rss': 'simultaneous observer parent plus discoverable descendants', + 'limitations': '10ms sampling can miss short peaks/processes; PID start ticks prevent reuse conflation; an unseen reparented/escaped process can be missed; proc RSS includes shared pages per process; no exact true peak claim', + 'cpu': 'entire fresh observer lifetime SELF plus reaped-children rusage; child usage includes descendants reaped by their parents; no summing sampled CPU', + 'individual_maxrss': 'kernel SELF and CHILDREN maxima are separate individual process high water marks; never summed as concurrent peak', + 'interpreter_startup': 'before first Python instruction is measured only by enclosing canonical guard; OPEN_NOT_ZERO otherwise', + 'cgroup_peak': 'NOT_COLLECTED; no cgroup isolation/peak claim'}} + try: + need(admission['operation'] in admission['fixed_order'], 'undeclared operation') + index = admission['fixed_order'].index(admission['operation']) + need(len(set(admission['fixed_order'])) == len(admission['fixed_order']), 'duplicate operation labels') + if index: + previous = read_json(Path(admission['previous_observer_receipt']), admission['previous_observer_sha256']) + need(previous['status'] == 'PASS' and previous['operation'] == admission['fixed_order'][index - 1], 'fixed predecessor missing/failed') + for filename, expected in admission['envelope_source_files'].items(): + same(Path(filename), expected) + from bootstrap import closure + from effective import capture, unchanged + runtime = read_json(Path(admission['runtime_manifest']), admission['runtime_sha256']) + import importlib + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + for name in runtime['preload_modules']: + importlib.import_module(name) + record['observer_runtime_before'], observer_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + record['effective_before'] = effective_before + worker = Path(admission['worker']) + need(str(worker) in admission['envelope_source_files'], 'worker source unsealed') + command = [admission['interpreter'], '-B', '-I', '-S', str(worker), '--admission', + str(Path(args.admission)), '--admission-sha256', args.admission_sha256] + remaining = ledger['cap_seconds'] - ledger['spent_seconds'] + record['execution'] = observe(command, str(folder), folder / 'guard', + START + min(TIME_CAP, remaining)) + need(record['execution']['exit'] == 0 and record['execution']['termination'] is None, + 'worker/guard failure') + need(record['execution']['logs']['stderr']['size'] == 0, 'worker stderr') + worker_receipt = read_json(folder / 'worker-receipt.json') + need(worker_receipt['status'] == 'PASS', 'worker receipt failure') + record['worker_receipt'] = pin(folder / 'worker-receipt.json') + for filename, expected in admission['envelope_source_files'].items(): + same(Path(filename), expected) + for filename, expected in ledger['fresh_files'].items(): + same(Path(filename), expected) + except BaseException as error: + record['errors'].append({'type': type(error).__name__, 'message': str(error)}) + try: + record['observer_runtime_after'], after_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(after_objects[k] is v for k, v in observer_objects.items()), 'observer callable drift') + record['effective_after'] = capture(dict(sys.modules)) + unchanged(effective_before, record['effective_after']) + except BaseException as error: + record['errors'].append({'check': 'observer-runtime-after', 'type': type(error).__name__, 'message': str(error)}) + try: + for filename, expected in admission['envelope_source_files'].items(): + same(Path(filename), expected) + for filename, expected in ledger['fresh_files'].items(): + same(Path(filename), expected) + except BaseException as error: + record['errors'].append({'check': 'closing-source-ledger', 'type': type(error).__name__, 'message': str(error)}) + stop_sampling.set() + sampling_thread.join() + record['inclusive_sampled_simultaneous_tree_rss_bytes'] = inclusive['peak'] + record['inclusive_samples'] = inclusive['samples'] + record['inclusive_sampler_errors'] = inclusive['errors'] + if inclusive['peak'] > RSS_CAP or inclusive['errors']: + record['errors'].append({'type': 'SamplerFailure', 'message': 'inclusive cap/sampler failure'}) + record['cpu_accounting'] = ('COMPLETE_FOR_SOURCE_FIXED_REAPED_SUCCESS_TREE' if not record['errors'] else + 'FAILED_ATTEMPT_REAPING_OR_KILL_GAPS_OPEN_NOT_ZERO') + record['operation'] = admission['operation'] + self_end, child_end = resource.getrusage(resource.RUSAGE_SELF), resource.getrusage(resource.RUSAGE_CHILDREN) + record['cpu_seconds'] = {'parent_user': self_end.ru_utime, + 'parent_system': self_end.ru_stime, + 'reaped_children_user': child_end.ru_utime, + 'reaped_children_system': child_end.ru_stime} + record['kernel_individual_maxrss_kib'] = {'observer_self_lifetime': self_end.ru_maxrss, + 'reaped_children_individual_maximum': child_end.ru_maxrss} + record['inclusive_wall_seconds'] = time.monotonic() - START + record['policy_charge_seconds'] = record['inclusive_wall_seconds'] + if record['inclusive_wall_seconds'] > min(TIME_CAP, 2400 - ledger['spent_seconds']): + record['errors'].append({'type': 'CapFailure', 'message': 'closing checks exceeded cap'}) + record['status'] = 'PASS' if not record['errors'] else 'STOP' + # The finite final write and exactly one parent readback are outside above endpoint. + write_json(folder / 'observer-receipt.json', record) + if record['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer_controls.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer_controls.py new file mode 100644 index 0000000000..c7284fe90a --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer_controls.py @@ -0,0 +1,69 @@ +"""Six fixed concrete observer controls. Run only under admitted outer guard.""" +import argparse +import os +from pathlib import Path +import sys +import time +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, write_json +from observer import observe, process_table + +CASES = ('bounded-child-allocation', 'concurrent-parent-child-allocation', 'short-lived-child', + 'timeout-kill-reap', 'pid-membership-and-reaped-cleanup', 'sampled-cap-kill-reap') + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--output-root', required=True) + parser.add_argument('--receipt', required=True) + parser.add_argument('--runtime-manifest', required=True) + parser.add_argument('--runtime-sha256', required=True) + args = parser.parse_args() + root = Path(args.output_root) + root.mkdir(mode=0o700) + fixture = str(Path(__file__).resolve().with_name('observer_fixture.py')) + rows = [] + modes = ('allocation', 'concurrent', 'short', 'timeout', 'membership', 'allocation-cap') + for index, (name, mode) in enumerate(zip(CASES, modes)): + parent = None + before_rss = process_table()[os.getpid()]['rss_bytes'] + if mode == 'concurrent': + parent = bytearray(16 * 1024 * 1024) + for offset in range(0, len(parent), 4096): + parent[offset] = 1 + cap = before_rss + 24 * 1024 * 1024 if mode == 'allocation-cap' else 1073741824 + deadline = time.monotonic() + (0.08 if mode == 'timeout' else 5.0) + row = observe([sys.executable, '-B', '-I', '-S', fixture, mode, args.runtime_manifest, args.runtime_sha256], str(root), root / ('case-%02d' % index), + deadline, rss_cap=cap) + need(row['logs']['stderr']['size'] == 0, 'fixture stderr') + if mode in ('allocation', 'concurrent', 'short'): + need(row['exit'] == 0 and row['termination'] is None, name + ' failed') + elif mode == 'timeout': + need(row['termination'] == 'wall_or_aggregate_cap' and row['exit'] != 0, 'timeout not detected') + elif mode == 'membership': + need(row['exit'] == 0 and row['termination'] is None and len(row['tracked_identities']) >= 3, + 'parent/child membership and waited cleanup not observed') + else: + need(row['termination'] == 'sampled_tree_rss_cap' and row['exit'] != 0, 'memory cap not detected') + if mode == 'allocation': + need(row['sampled_simultaneous_tree_rss_bytes'] >= before_rss + 16 * 1024 * 1024, 'child allocation missed') + if mode == 'concurrent': + need(row['sampled_simultaneous_tree_rss_bytes'] >= before_rss + 48 * 1024 * 1024, 'concurrent allocation missing') + need(len(row['tracked_identities']) >= 3, 'grandchild membership missing') + now = process_table() + # Every membership fixture explicitly waits for its child; any live + # same-identity descendant after return is a cleanup failure. + survivors = [int(pid) for pid, tick in row['tracked_identities'].items() + if int(pid) != os.getpid() and int(pid) in now and + now[int(pid)]['start_ticks'] == tick and now[int(pid)]['rss_bytes'] > 0] + need(not survivors, 'live fixture survived cleanup') + rows.append({'case': name, 'status': 'PASS', 'measurement': row, + 'short_peak_guaranteed_observed': False}) + del parent + write_json(Path(args.receipt), {'schema': 'o03-observer-controls-v1', 'status': 'PASS', + 'case_count': 6, 'ordered_cases': list(CASES), 'cases': rows, + 'sampling_limits_exposed': True, 'synthetic_controls_are_full_serializer_evidence': False}) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer_fixture.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer_fixture.py new file mode 100644 index 0000000000..8f1715e979 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/observer_fixture.py @@ -0,0 +1,56 @@ +"""Fixed small observer-control child; never used as a serializer substitute.""" +import os +from pathlib import Path +import subprocess +import sys +import time + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from bootstrap import closure +from custody import need, read_json +from effective import capture, unchanged + + +def main(): + mode = sys.argv[1] + runtime_path, runtime_sha = sys.argv[2:4] + runtime = read_json(Path(runtime_path), runtime_sha) + package = Path(__file__).resolve().parent.parent + before, objects = closure(runtime, package, Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + if mode == 'allocation': + data = bytearray(16 * 1024 * 1024) + for i in range(0, len(data), 4096): + data[i] = 1 + time.sleep(0.20) + elif mode == 'concurrent': + data = bytearray(16 * 1024 * 1024) + for i in range(0, len(data), 4096): + data[i] = 1 + child = subprocess.Popen([sys.executable, '-B', '-I', '-S', str(Path(__file__).resolve()), 'allocation', runtime_path, runtime_sha]) + child.wait() + if child.returncode: + raise SystemExit(child.returncode) + elif mode == 'short': + data = bytearray(1024) + elif mode == 'timeout': + time.sleep(2.0) + elif mode == 'membership': + child = subprocess.Popen([sys.executable, '-B', '-I', '-S', str(Path(__file__).resolve()), 'allocation', runtime_path, runtime_sha]) + child.wait() + if child.returncode: + raise SystemExit(child.returncode) + elif mode == 'allocation-cap': + data = bytearray(32 * 1024 * 1024) + for i in range(0, len(data), 4096): + data[i] = 1 + time.sleep(0.20) + else: + raise RuntimeError('undeclared fixture mode') + after, actual = closure(runtime, package, Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(actual[k] is v for k, v in objects.items()), 'fixture callable drift') + unchanged(effective_before, capture(dict(sys.modules))) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/parent_readback.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/parent_readback.py new file mode 100644 index 0000000000..9afd005ec9 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/parent_readback.py @@ -0,0 +1,62 @@ +"""One finite parent readback of observer+outer-time records; outside tail is open. + +No targets are imported or repeated. A passing readback exposes conservative +full-command canonical policy charge, never just the observer's inner timer. +""" +import argparse +import math +from pathlib import Path +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, pin, read_json, write_json + + +def main(): + parser = argparse.ArgumentParser() + for name in ('admission', 'admission-sha256', 'observer-record', 'outer-time', 'report'): + parser.add_argument('--' + name, required=True) + args = parser.parse_args() + admission = read_json(Path(args.admission), args.admission_sha256) + observer = read_json(Path(args.observer_record)) + outer = read_json(Path(args.outer_time)) + state = {'schema': 'o03-one-parent-readback-v2', 'status': 'STARTED', 'errors': [], + 'tail_cost': 'OPEN_NOT_ZERO', 'publication_cost': 'OPEN_NOT_ZERO', + 'readback_operations': 1, 'observer_record': pin(Path(args.observer_record)), + 'outer_time_record': pin(Path(args.outer_time)), 'canonical_ledger_written_here': False} + try: + need(observer['admission_sha256'] == args.admission_sha256 and + observer['operation'] == 'complete-fixed-o03' and observer['status'] == 'PASS', 'observer did not pass exact admitted operation') + need(observer.get('cpu_accounting') == 'COMPLETE_FOR_SOURCE_FIXED_REAPED_SUCCESS_TREE', 'CPU accounting did not close fixed reaped tree') + need(outer['exit'] == 0, 'outer command exit failed') + for name in ('wall_seconds', 'user_seconds', 'system_seconds', 'kernel_individual_maxrss_kib'): + need(type(outer[name]) in (int, float) and math.isfinite(outer[name]) and outer[name] >= 0, 'invalid outer measurement: ' + name) + need(outer['kernel_individual_maxrss_kib'] * 1024 <= 1073741824, 'outer kernel individual maxRSS exceeds1GiB') + need(observer['inclusive_sampled_simultaneous_tree_rss_bytes'] <= 1073741824 and + not observer['inclusive_sampler_errors'] and observer['inclusive_samples'] > 0, 'inclusive sampler invalid') + # GNU time %e has hundredth-second textual precision; charge a complete + # upper rounding quantum to avoid undercharging the full outer span. + charge = outer['wall_seconds'] + 0.01 + state['full_outer_wall_seconds_reported'] = outer['wall_seconds'] + state['outer_wall_rounding_allowance_seconds'] = 0.01 + state['canonical_policy_charge_seconds'] = charge + need(observer['inclusive_wall_seconds'] <= charge, 'outer timer shorter than observed core') + need(charge <= 180 and admission['canonical_ledger']['spent_seconds'] + charge <= 2400, + 'full outer command or aggregate policy cap exceeded') + observed_cpu = sum(observer['cpu_seconds'].values()) + need(outer['user_seconds'] + outer['system_seconds'] + 0.03 >= observed_cpu, + 'outer CPU excludes declared observer/descendant CPU') + state['full_outer_cpu_seconds_reported'] = outer['user_seconds'] + outer['system_seconds'] + state['individual_maxrss_kib'] = outer['kernel_individual_maxrss_kib'] + state['simultaneous_sampled_rss_bytes'] = observer['inclusive_sampled_simultaneous_tree_rss_bytes'] + state['outside_tail'] = observer['outside_tail'] + state['qualification'] = 'Measurement/readback eligibility only; independent P5/O03 adjudication and canonical ledger reconciliation remain required.' + except BaseException as error: + state['errors'].append({'type': type(error).__name__, 'message': str(error)}) + state['status'] = 'PASS' if not state['errors'] else 'STOP' + write_json(Path(args.report), state) + if state['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/sequence_worker.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/sequence_worker.py new file mode 100644 index 0000000000..bb92d5bdba --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/sequence_worker.py @@ -0,0 +1,87 @@ +"""Fixed eight-operation serial coordinator inside one inclusive180s command. + +One outer observer receipt and one parent readback close this finite operation. +No intermediate parent process/action, retries, rerolls or fresh admission from +candidate observations. Every child is reaped before the next child starts. +""" +import argparse +import hashlib +from pathlib import Path +import subprocess +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, pin, read_json, write_json + +ORDER = ('observer-controls', 'loader-controls-normal', 'consumer-controls-normal', + 'loader-controls-O', 'consumer-controls-O', 'baseline-first', 'candidate-first', 'independent-validation') + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--admission', required=True) + parser.add_argument('--admission-sha256', required=True) + args = parser.parse_args() + admission = read_json(Path(args.admission), args.admission_sha256) + need(admission['operation'] == 'complete-fixed-o03', 'fixed operation required') + need(tuple(job['id'] for job in admission['sequence']) == ORDER, 'fixed serial order differs') + root = Path(admission['operation_root']) + steps = root / 'steps' + steps.mkdir(mode=0o700) + state = {'schema': 'o03-fixed-sequence-v1', 'status': 'STARTED', 'ordered_operations': list(ORDER), 'steps': [], 'errors': []} + try: + from custody import same + from bootstrap import closure + from effective import capture, unchanged + import importlib + runtime = read_json(Path(admission['runtime_manifest']), admission['runtime_sha256']) + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + for name in runtime['preload_modules']: + importlib.import_module(name) + state['runtime_before'], objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + for job in admission['sequence']: + step_root = steps / job['id'] + step_root.mkdir(mode=0o700) + child = dict(admission, operation=job['id'], operation_root=str(step_root), job=job) + child.pop('sequence') + child['dependency_receipts'] = {} + child['dependency_output_roots'] = {} + if job['id'] == 'independent-validation': + for arm, label in (('baseline', 'baseline-first'), ('candidate', 'candidate-first')): + prior_root = steps / label + child['dependency_receipts'][arm + '_receipt'] = { + 'path': str(prior_root / 'target-receipt.json'), 'pin': pin(prior_root / 'target-receipt.json')} + child['dependency_output_roots'][arm + '_root'] = str(prior_root / 'outputs') + path = root / (job['id'] + '-request.json') + write_json(path, child) + sha = pin(path)['sha256'] + command = [admission['interpreter'], '-B', '-I', '-S', str(Path(__file__).resolve().with_name('worker.py')), + '--admission', str(path), '--admission-sha256', sha] + completed = subprocess.run(command, cwd=root, stdin=subprocess.DEVNULL, check=False) + row = {'id': job['id'], 'exit': completed.returncode, 'request': pin(path)} + state['steps'].append(row) + need(completed.returncode == 0, 'fixed operation failed: ' + job['id']) + receipt = read_json(step_root / 'worker-receipt.json') + need(receipt['status'] == 'PASS', 'worker receipt failed') + row['worker_receipt'] = pin(step_root / 'worker-receipt.json') + # Full independent validator already performed byte/receipt/cleanup checks; + # all step receipts are reread here inside observation, never outside tail. + for row in state['steps']: + expected = row['worker_receipt'] + need(pin(steps / row['id'] / 'worker-receipt.json') == expected, 'step receipt drift') + state['runtime_after'], actual = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(actual[k] is v for k, v in objects.items()), 'sequence callable drift') + unchanged(effective_before, capture(dict(sys.modules))) + except BaseException as error: + state['errors'].append({'type': type(error).__name__, 'message': str(error)}) + state['status'] = 'PASS' if not state['errors'] else 'STOP' + write_json(root / 'worker-receipt.json', state) + if state['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/worker.py b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/worker.py new file mode 100644 index 0000000000..35edac21bd --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/envelope/worker.py @@ -0,0 +1,120 @@ +"""Single fixed-operation coordinator inside inclusive observer; no target imports.""" +import argparse +import hashlib +import os +from pathlib import Path +import subprocess +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import check_snapshot, need, pin, read_json, safe, same, stage, write_json + + +def subst(value, bindings): + for key, replacement in bindings.items(): + value = value.replace('{' + key + '}', replacement) + need('{' not in value and '}' not in value, 'unresolved command binding') + return value + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--admission', required=True) + parser.add_argument('--admission-sha256', required=True) + args = parser.parse_args() + admission = read_json(Path(args.admission), args.admission_sha256) + operation = admission['operation'] + root = safe(Path(admission['operation_root'])) + job = admission['job'] + need(job['id'] == operation, 'operation/job mismatch') + state = {'schema': 'o03-worker-receipt-v1', 'operation': operation, 'status': 'STARTED', 'errors': []} + package_custody, input_custody = None, None + try: + # Fresh separately owned copies are made under the already live outer observation. + package_custody = stage(root / 'package', admission['package_sources']) + state['package_before'] = package_custody + runtime = read_json(Path(admission['runtime_manifest']), admission['runtime_sha256']) + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + from bootstrap import closure + from effective import capture, unchanged + import importlib + for name in runtime['preload_modules']: + importlib.import_module(name) + state['worker_runtime_before'], worker_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + state['effective_before'] = effective_before + bindings = {'package': str(root / 'package'), 'operation_root': str(root), + 'output_root': str(root / 'outputs'), 'receipt': str(root / 'target-receipt.json'), + 'runtime_manifest': admission['runtime_manifest'], 'runtime_sha256': admission['runtime_sha256']} + if job['needs_authentic_inputs']: + input_custody = stage(root / 'inputs', admission['input_sources']) + # Loader schema exact: no wrapper/metadata extra file enters the input root. + write_json(root / 'input-custody.json', input_custody) + state['input_before'] = input_custody + bindings.update(input_root=str(root / 'inputs'), custody_json=str(root / 'input-custody.json')) + for key, spec in admission.get('dependency_receipts', {}).items(): + path = safe(Path(spec['path'])) + same(path, spec['pin']) + bindings[key] = str(path) + for key, directory in admission.get('dependency_output_roots', {}).items(): + bindings[key] = str(safe(Path(directory))) + argv = [subst(value, bindings) for value in job['argv']] + request = {'package_custody': package_custody, 'entry': job['entry'], 'argv': argv, + 'runtime_manifest': admission['runtime_manifest'], 'runtime_sha256': admission['runtime_sha256'], + 'runtime_report': str(root / 'effective-runtime.json'), + 'effective_package_preloads': job['effective_package_preloads']} + write_json(root / 'bootstrap-request.json', request) + request_sha = pin(root / 'bootstrap-request.json')['sha256'] + bootstrap = root / 'package/envelope/bootstrap.py' + need('envelope/bootstrap.py' in package_custody['files'], 'bootstrap absent') + command = [admission['interpreter'], '-B', '-I', '-S'] + if job['optimization'] == 1: + command.append('-O') + else: + need(job['optimization'] == 0, 'invalid optimization') + command += [str(bootstrap), str(root / 'bootstrap-request.json'), request_sha] + state['command'] = command + # The outer observer owns the only real180s/1GiB/aggregate guard and logs. + completed = subprocess.run(command, cwd=root, stdin=subprocess.DEVNULL, check=False) + state['target_exit'] = completed.returncode + need(completed.returncode == 0, 'bootstrap/target failed') + effective = read_json(root / 'effective-runtime.json') + need(effective['status'] == 'PASS', 'runtime before/after failed') + receipt = read_json(root / 'target-receipt.json') + for key, expected in job['receipt_predicates'].items(): + need(receipt.get(key) == expected, 'target receipt predicate failed: ' + key) + state['target_receipt'] = pin(root / 'target-receipt.json') + # Receipt and runtime closure readbacks, source checks and genuine-input cleanup + # checks remain substantive measured work before worker exits. + state['runtime_report'] = pin(root / 'effective-runtime.json') + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + state['worker_runtime_after'], after_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(after_objects[k] is v for k, v in worker_objects.items()), 'worker callable drift') + state['effective_after'] = capture(dict(sys.modules)) + unchanged(effective_before, state['effective_after']) + for key, spec in admission.get('dependency_receipts', {}).items(): + same(Path(spec['path']), spec['pin']) + for relative in job['must_be_absent_after']: + path = root / relative + need(not path.exists() and not path.is_symlink(), 'cleanup failed: ' + relative) + except BaseException as error: + state['errors'].append({'type': type(error).__name__, 'message': str(error)}) + finally: + for name, custody in (('package_after', package_custody), ('input_after', input_custody)): + if custody is not None: + try: + state[name] = check_snapshot(custody) + except BaseException as error: + state['errors'].append({'check': name, 'type': type(error).__name__, 'message': str(error)}) + state['retention'] = 'immutable staged inputs/sources and complete first-attempt evidence intentionally retained; candidate private staging absence checked by target validator; no silently deleted failures' + state['status'] = 'PASS' if not state['errors'] else 'STOP' + write_json(root / 'worker-receipt.json', state) + if state['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/package-provenance/anchor.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/package-provenance/anchor.json new file mode 100644 index 0000000000..a593a05004 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/package-provenance/anchor.json @@ -0,0 +1 @@ +{"base_commit":"19fdb086ea96af9a9f87936a2b888e10af4ed810","driver_sha256":"0d976d2eb6b845f20d4a3396591a806f966688b88693cd6a5f8a0c9e48925e36","engine_pins":{"compare_side_verifier.py":"6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68","finite_controls.py":"df989a831aac43cc1af95169dad8c64a7548760e6e1f96976da996703f2c8f7a","native_backend.py":"e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5","native_gf2.c":"e9c3c9194a08718bd1575c1cf08c6c6772d3b644c2e274c25a84a1f9249d06cc","profile_side_verifier.py":"9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a","source/complex_circuit.py":"d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1","source/complex_network.py":"0da395e67ac04fa213494e71012c1b19b544596d34cdce5a3b172b1fb6af5f1b"},"schema":"gf2-full-network-anchor-v1","science":{"full_cli_certificate_sha256":"1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f","full_cli_stdout_sha256":"8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015","full_return_lossless_sha256":"542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd","ordered_complements":{"calls":238685,"canonical_stream_bytes":55839507,"schema":"v2-jsonl:call,us,vs,result(type=list+values or type=None); ordered exact integer vectors","sha256":"7dec2bf33303c37e1c699609e83768d61df7e19104d34a26a148f66d5ccc4838"},"side":{"exact_witness_sha256":"4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82","rank_call_count":59959,"rank_distinct_matrix_count":252,"rank_trace_sha256":"85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f","result_sha256":"342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c","serialized_bytes":{"rank_trace":2674272,"result":527,"witness":58143622}},"upstream_commit":"adc7f1241b42e322a6451854ab7e4b4c146bf78a"},"source_pin_sha256":"88bba3caf5975f30fa7abceaea9454110cf3b069233e8241a2ca13d1dff171a7"} diff --git a/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/package-provenance/canonical-MANIFEST.json b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/package-provenance/canonical-MANIFEST.json new file mode 100644 index 0000000000..95917d3e64 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/envelope-revision-v2/package-provenance/canonical-MANIFEST.json @@ -0,0 +1,47 @@ +{ + "artifacts": { + "complement-transcript.json": { + "encoding": "plain", + "logical_bytes": 227, + "logical_sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8", + "transport_bytes": 227, + "transport_sha256": "36ef2bbc469c1e701bfc06b0d240aa31575f82132e8d204f0fa2e1802b21fea8" + }, + "complex-network.json": { + "encoding": "plain", + "logical_bytes": 5662, + "logical_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "transport_bytes": 5662, + "transport_sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "full-return.lossless.json.gz": { + "encoding": "gzip", + "logical_bytes": 7311, + "logical_sha256": "542e4fd73d38b88122d1bf0fffa5f3b092cc4681a14012162daef47e89363cfd", + "transport_bytes": 2360, + "transport_sha256": "2ccdc80933fe4b3d774cf71ad2877864aca64e7de48b62c6391f449f2d2a67c2" + }, + "original-stdout.txt": { + "encoding": "plain", + "logical_bytes": 137, + "logical_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015", + "transport_bytes": 137, + "transport_sha256": "8f77b724810ec05fb19b35d75d8002d31a6e22ed342a36ee28a5caef8d643015" + }, + "rank-trace.json.gz": { + "encoding": "gzip", + "logical_bytes": 2674272, + "logical_sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f", + "transport_bytes": 22029, + "transport_sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "witness.json.gz": { + "encoding": "gzip", + "logical_bytes": 58143622, + "logical_sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82", + "transport_bytes": 16995263, + "transport_sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + } + }, + "schema_version": 1 +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/complete-fixed-o03/observer-receipt.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/complete-fixed-o03/observer-receipt.json new file mode 100644 index 0000000000..46b56f1b25 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/complete-fixed-o03/observer-receipt.json @@ -0,0 +1,47 @@ +{ + "admission_sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "cpu_accounting": "FAILED_ATTEMPT_REAPING_OR_KILL_GAPS_OPEN_NOT_ZERO", + "cpu_seconds": { + "parent_system": 0.048547, + "parent_user": 0.257198, + "reaped_children_system": 0.0, + "reaped_children_user": 0.0 + }, + "errors": [ + { + "message": "unsealed mapped files: ['/usr/lib/locale/locale-archive']", + "type": "RuntimeError" + }, + { + "check": "observer-runtime-after", + "message": "unsealed mapped files: ['/usr/lib/locale/locale-archive']", + "type": "RuntimeError" + } + ], + "inclusive_sampled_simultaneous_tree_rss_bytes": 19726336, + "inclusive_sampler_errors": [], + "inclusive_samples": 24, + "inclusive_wall_seconds": 0.2906860989751294, + "kernel_individual_maxrss_kib": { + "observer_self_lifetime": 19392, + "reaped_children_individual_maximum": 0 + }, + "measurement": { + "cgroup_peak": "NOT_COLLECTED; no cgroup isolation/peak claim", + "cpu": "entire fresh observer lifetime SELF plus reaped-children rusage; child usage includes descendants reaped by their parents; no summing sampled CPU", + "individual_maxrss": "kernel SELF and CHILDREN maxima are separate individual process high water marks; never summed as concurrent peak", + "interpreter_startup": "before first Python instruction is measured only by enclosing canonical guard; OPEN_NOT_ZERO otherwise", + "limitations": "10ms sampling can miss short peaks/processes; PID start ticks prevent reuse conflation; an unseen reparented/escaped process can be missed; proc RSS includes shared pages per process; no exact true peak claim", + "sampled_rss": "simultaneous observer parent plus discoverable descendants" + }, + "operation": "complete-fixed-o03", + "outside_tail": { + "cost": "OPEN_NOT_ZERO", + "final_observer_record_writes": 1, + "parent_readbacks": 1, + "publication": "OPEN_NOT_ZERO" + }, + "policy_charge_seconds": 0.2906860989751294, + "schema": "o03-inclusive-observer-v1", + "status": "STOP" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/COMMAND-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/COMMAND-v1.json new file mode 100644 index 0000000000..0072b2eecd --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/COMMAND-v1.json @@ -0,0 +1,36 @@ +{ + "admission": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "argv": [ + "/usr/bin/env", + "-i", + "PATH=/usr/bin:/bin", + "LC_ALL=C.UTF-8", + "TZ=UTC", + "/usr/bin/timeout", + "--signal=TERM", + "--kill-after=1s", + "179s", + "/usr/bin/time", + "-f", + "{\"wall_seconds\":%e,\"user_seconds\":%U,\"system_seconds\":%S,\"kernel_individual_maxrss_kib\":%M,\"exit\":%x}", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json", + "--", + "/usr/bin/python3.12", + "-B", + "-I", + "-S", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py", + "--admission", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "--admission-sha256", + "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + ], + "command": "/usr/bin/env -i PATH=/usr/bin:/bin LC_ALL=C.UTF-8 TZ=UTC /usr/bin/timeout --signal=TERM --kill-after=1s 179s /usr/bin/time -f '{\"wall_seconds\":%e,\"user_seconds\":%U,\"system_seconds\":%S,\"kernel_individual_maxrss_kib\":%M,\"exit\":%x}' -o /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json -- /usr/bin/python3.12 -B -I -S /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py --admission /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json --admission-sha256 fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "once_only": true, + "status": "PENDING_INDEPENDENT_I4_REVIEW" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/I4-PACKET-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/I4-PACKET-v1.json new file mode 100644 index 0000000000..3884b084b4 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/I4-PACKET-v1.json @@ -0,0 +1,28 @@ +{ + "admission": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "command": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "created_utc": "2026-10-31T08:35:25.405240+00:00", + "ledger_reconciliation": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + "original_O03_credit": 0, + "permission": "PARENT_APPROVES_EXACT_FIXED_OPERATION_AFTER_INDEPENDENT_I4_ACCEPT", + "readback": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-COMMAND-v1.json", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + "runtime_operations": 0, + "schema": "o03-exact-parent-I4-proposal-v1", + "source_acceptance": { + "path": "streams/serializer-o03-implementation-20261031/review/COMBINED-SOURCE-REVIEW-v1.json", + "sha256": "f73a19d43ee254b3fdafaaccfa3439ffdda87f84067213a8a39d5393668226d0" + }, + "source_changes": 0 +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/LEDGER-RECONCILIATION-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/LEDGER-RECONCILIATION-v1.json new file mode 100644 index 0000000000..d8f75fa552 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/LEDGER-RECONCILIATION-v1.json @@ -0,0 +1,78 @@ +{ + "active_canonical_exec_session": null, + "all_other_guarded_work_paused": true, + "chain": [ + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json", + "policy_seconds": "94.210533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-005.json", + "policy_seconds": "90.910533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-004.json", + "policy_seconds": "87.710533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-003.json", + "policy_seconds": "84.450533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-002.json", + "policy_seconds": "80.960533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-001.json", + "policy_seconds": "78.310533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-004.json", + "policy_seconds": "75.750533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-003.json", + "policy_seconds": "73.470533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-002.json", + "policy_seconds": "71.200533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-001.json", + "policy_seconds": "68.630533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LEDGER-001.json", + "policy_seconds": "66.090533479", + "status": "STOP_BEFORE_COMPONENT_IMPORT" + } + ], + "controller_tail_historical_costs": "OPEN_NOT_ZERO", + "created_utc": "2026-10-31T08:35:25.405240+00:00", + "current_policy_seconds": "94.210533479", + "initial_cap_seconds": 600, + "latest_ledger": { + "path": "streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json", + "sha256": "d323469d15edef8ef803ca4241dcd7164010fd77044286220d2ef0d6bf7e15fd" + }, + "lock": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "new_allowance": false, + "new_round_runtime_operations_before_this": 0, + "physical_total_seconds": null, + "reserved_maximum_seconds": "180", + "schema": "o03-current-ledger-reconciliation-v1", + "scope": "Existing serializer and digest terminal ledgers/round closes plus source-only named-round state; no unclosed new operation exists. Historic physical gaps preserved.", + "total_cap_seconds": 2400, + "upper_after_operation": "274.210533479" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/READBACK-COMMAND-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/READBACK-COMMAND-v1.json new file mode 100644 index 0000000000..a3a2c9a950 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/READBACK-COMMAND-v1.json @@ -0,0 +1,27 @@ +{ + "admission": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "argv": [ + "/usr/bin/python3.12", + "-B", + "-I", + "-S", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py", + "--admission", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "--admission-sha256", + "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "--observer-record", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json", + "--outer-time", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json", + "--report", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/parent-readback.json" + ], + "command": "/usr/bin/python3.12 -B -I -S /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py --admission /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json --admission-sha256 fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1 --observer-record /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json --outer-time /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json --report /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/parent-readback.json", + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "once_only": true, + "status": "PENDING_INDEPENDENT_I4_REVIEW" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/complete-fixed-o03-admission.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/complete-fixed-o03-admission.json new file mode 100644 index 0000000000..96d2d36b68 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control-proposal/complete-fixed-o03-admission.json @@ -0,0 +1,630 @@ +{ + "canonical_ledger": { + "cap_seconds": 2400, + "fresh_files": { + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/control/AGENT-TASK-INDEX-native-fields-v385.json": { + "sha256": "06beb4ec41a750959b3a441f2eaaa3d930680b80f869d5bab643aeb3b393afb5", + "size": 328583 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/control/ROUND-CLOSE-v1.json": { + "sha256": "211a0e5440bbccc404b5113b64d44fe9fc985ef5817a78a4f904a94a714dd82d", + "size": 1844 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-001.json": { + "sha256": "9f00b5b1f8760a9254a8bc93af2f92f93c763e991b0d9daa062f9b27920ed7e4", + "size": 2965 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-002.json": { + "sha256": "525b5c3fb927d947db28ce4aa83e97a249688d68505ad30e3117a22000a7ee78", + "size": 2920 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-003.json": { + "sha256": "d068465be6fc557983031a7a7c9b5f9e1f2670227f72eb1a23dfffe72df8c547", + "size": 2920 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-004.json": { + "sha256": "e5795c9f6640a5ac417c14dcf25255ad39b970b27341638e62b0dcdaa08ca5a4", + "size": 2927 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-005.json": { + "sha256": "0cd8093d3f6de2618a437adc5164416b8fb3190c039491cd184c5a30223f43b3", + "size": 2927 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-006.json": { + "sha256": "e9063e1f1f40b8a97994d3faa4591e1ed0cfa00696dccda505f15ef50026c4a2", + "size": 2920 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-001.json": { + "sha256": "5f727491e2c54925229e74f855ad7b881b5dac8a958474300f1b226b8134ebca", + "size": 2025 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-002.json": { + "sha256": "344cc1cb001843244a7d873c8c95f797cffd19eefd38b84ceab028d283400e9a", + "size": 1995 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-003.json": { + "sha256": "341c6c55ebe45b3f06a7d5f7c57eede4276541f5eca109e53c6ec49707ce6e86", + "size": 1995 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-004.json": { + "sha256": "4e9cfd0d4c29a5bfdc9fc3d0ab33c179329c0b2efa7962ba6e6f2b4b5de50ca8", + "size": 1999 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-005.json": { + "sha256": "ca3c54527ba7a23359dca6873e2ab69245b739c2b577fb6072bf2a954f871d81", + "size": 1999 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json": { + "sha256": "d323469d15edef8ef803ca4241dcd7164010fd77044286220d2ef0d6bf7e15fd", + "size": 1995 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/control/ROUND-CLOSE-v1.json": { + "sha256": "c859ab874ef8f46ffe417b22ed46a6d78ad6d9688bfb5d7113d2a494ff8830de", + "size": 775 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LEDGER-001.json": { + "sha256": "f29bae9908352221e2f6341e137ad39e22899efccaf7151eb1962e9b85447e6b", + "size": 2093 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-001.json": { + "sha256": "18d39ae470e131249a0380bf254d140739c6ddc41e29cd0d29f511bd88312448", + "size": 2954 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-002.json": { + "sha256": "9773784a0a02b08b4f3972fe0e954006d626700093a122ccebfc0ed5d89d3bd3", + "size": 2924 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-003.json": { + "sha256": "79cefa10887c393c80bb78b1038155013605252f81383648920d771bdbb9c500", + "size": 2923 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-004.json": { + "sha256": "8cf5f8b1a1e53436d02cd3be99ffd114f6582433db9b1f6ab19d8ae0ab6bc2e8", + "size": 2982 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/PLAN-v1.md": { + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234", + "size": 6135 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/control/AUTHORIZATION-v1.json": { + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2", + "size": 1169 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json": { + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933", + "size": 4139 + } + }, + "lock_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "spent_seconds": 94.210533479 + }, + "consumed_marker": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-consumed", + "envelope_source_files": { + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py": { + "mode": 292, + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py": { + "mode": 292, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py": { + "mode": 292, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py": { + "mode": 292, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py": { + "mode": 292, + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py": { + "mode": 292, + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py": { + "mode": 292, + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py": { + "mode": 292, + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py": { + "mode": 292, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py": { + "mode": 292, + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + } + }, + "fixed_order": [ + "complete-fixed-o03" + ], + "independent_source_accepted": true, + "input_sources": { + "baseline/evidence/canonical/complex-network.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "size": 5662 + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "size": 22029 + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "size": 16995263 + } + }, + "interpreter": "/usr/bin/python3.12", + "maximum_command_seconds": 180, + "operation": "complete-fixed-o03", + "operation_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03", + "package_sources": { + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583", + "size": 736 + }, + "consumer/CONTROL-SPEC.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423", + "size": 3062 + }, + "consumer/DEPENDENCIES-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69", + "size": 3934 + }, + "consumer/PACKAGE-PINS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PACKAGE-PINS-v1.json", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc", + "size": 2453 + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-ATTEMPTS-v1.json", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875", + "size": 719 + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-CHECKS-v1.json", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381", + "size": 2637 + }, + "consumer/README-v1.md": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/README-v1.md", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7", + "size": 6609 + }, + "consumer/SOURCE-READINESS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/SOURCE-READINESS-v1.json", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606", + "size": 2081 + }, + "consumer/bounded_serialization.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "size": 23560 + }, + "consumer/full_consumer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688", + "size": 9411 + }, + "consumer/reference.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968", + "size": 2141 + }, + "consumer/run_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf", + "size": 6630 + }, + "consumer/serialization_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "size": 23684 + }, + "consumer/validate_outputs.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e", + "size": 14577 + }, + "envelope/ELF-CLOSURE-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/ELF-CLOSURE-v2.json", + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "size": 8733 + }, + "envelope/FIXED-SEQUENCE-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/FIXED-SEQUENCE-v2.json", + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf", + "size": 5379 + }, + "envelope/RUNTIME-PINS-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "size": 28663 + }, + "envelope/bootstrap.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py", + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "envelope/custody.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "envelope/effective.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "envelope/loader_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "envelope/observer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py", + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "envelope/observer_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py", + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "envelope/observer_fixture.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py", + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "envelope/parent_readback.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py", + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "envelope/sequence_worker.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "envelope/worker.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py", + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + }, + "loader/API-v1.md": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/API-v1.md", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677", + "size": 5012 + }, + "loader/CONTROL-SPEC-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/CONTROL-SPEC-v1.json", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c", + "size": 2002 + }, + "loader/PACKAGE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PACKAGE-PINS-v1.json", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71", + "size": 1152 + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PASSIVE-ATTEMPTS-v1.json", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4", + "size": 586 + }, + "loader/SOURCE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e", + "size": 2395 + }, + "loader/SOURCE-READINESS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-READINESS-v1.json", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f", + "size": 2306 + }, + "loader/frozen_h25_inputs.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a", + "size": 14650 + }, + "loader/frozen_input_controls.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c", + "size": 13181 + }, + "provenance/anchor.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "size": 1926 + }, + "provenance/canonical-MANIFEST.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "size": 1912 + } + }, + "parent_boundary": { + "I7_qualification_still_required": true, + "controller_and_tail": "OPEN_NOT_ZERO", + "fixture_payload_bytes": 117441536, + "initial600_reservation_fits": true, + "no_dispatch_until_independent_I4_acceptance": true, + "no_retry_or_reroll": true + }, + "parent_execution_admitted": true, + "runtime_manifest": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "runtime_sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "sampled_group_cap_bytes": 1073741824, + "schema": "o03-envelope-admission-v1", + "sequence": [ + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}", + "--runtime-manifest", + "{runtime_manifest}", + "--runtime-sha256", + "{runtime_sha256}" + ], + "effective_package_preloads": [], + "entry": "envelope/observer_controls.py", + "id": "observer-controls", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "case_count": 6, + "ordered_cases": [ + "bounded-child-allocation", + "concurrent-parent-child-allocation", + "short-lived-child", + "timeout-kill-reap", + "pid-membership-and-reaped-cleanup", + "sampled-cap-kill-reap" + ], + "status": "PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "count": 39, + "optimize": 0, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 0, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "count": 39, + "optimize": 1, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 1, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--arm", + "baseline", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference" + ], + "entry": "consumer/full_consumer.py", + "id": "baseline-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "baseline", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--arm", + "candidate", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference", + "bounded_serialization" + ], + "entry": "consumer/full_consumer.py", + "id": "candidate-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "candidate", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--baseline-root", + "{baseline_root}", + "--candidate-root", + "{candidate_root}", + "--baseline-receipt", + "{baseline_receipt}", + "--candidate-receipt", + "{candidate_receipt}", + "--report", + "{receipt}" + ], + "effective_package_preloads": [], + "entry": "consumer/validate_outputs.py", + "id": "independent-validation", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "status": "COMPLETE_OUTPUTS_VALIDATED" + } + } + ], + "worker": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/COMMAND-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/COMMAND-v1.json new file mode 100644 index 0000000000..0072b2eecd --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/COMMAND-v1.json @@ -0,0 +1,36 @@ +{ + "admission": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "argv": [ + "/usr/bin/env", + "-i", + "PATH=/usr/bin:/bin", + "LC_ALL=C.UTF-8", + "TZ=UTC", + "/usr/bin/timeout", + "--signal=TERM", + "--kill-after=1s", + "179s", + "/usr/bin/time", + "-f", + "{\"wall_seconds\":%e,\"user_seconds\":%U,\"system_seconds\":%S,\"kernel_individual_maxrss_kib\":%M,\"exit\":%x}", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json", + "--", + "/usr/bin/python3.12", + "-B", + "-I", + "-S", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py", + "--admission", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "--admission-sha256", + "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + ], + "command": "/usr/bin/env -i PATH=/usr/bin:/bin LC_ALL=C.UTF-8 TZ=UTC /usr/bin/timeout --signal=TERM --kill-after=1s 179s /usr/bin/time -f '{\"wall_seconds\":%e,\"user_seconds\":%U,\"system_seconds\":%S,\"kernel_individual_maxrss_kib\":%M,\"exit\":%x}' -o /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json -- /usr/bin/python3.12 -B -I -S /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py --admission /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json --admission-sha256 fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "once_only": true, + "status": "PENDING_INDEPENDENT_I4_REVIEW" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/EXEC-RESULT-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/EXEC-RESULT-v1.json new file mode 100644 index 0000000000..c752d1fcbf --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/EXEC-RESULT-v1.json @@ -0,0 +1,7 @@ +{ + "chunk_id": "659865", + "wall_time_seconds": 0.256447657, + "exit_code": 1, + "original_token_count": 0, + "output": "" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/FAILURE-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/FAILURE-v1.json new file mode 100644 index 0000000000..6dc341d4bf --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/FAILURE-v1.json @@ -0,0 +1,25 @@ +{ + "CPU_seconds_reported": 0.32, + "control_replay_validator_results": "NOT_REACHED", + "created_utc": "2026-10-31T08:40:25.505600+00:00", + "ledger": { + "bytes": 2406, + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-001.json", + "sha256": "589b607e096d4ef7a49b38501827f1f5b865d1263591dff8b96cded9c7d62126" + }, + "next_dependency": "Independent failure attribution and evidence export only; another execution/source repair requires a new authorized round.", + "observer_child_CPU": 0.0, + "outer_individual_maxrss_kib": 19392, + "policy_charge_seconds": "0.34", + "primary_error": { + "message": "unsealed mapped files: ['/usr/lib/locale/locale-archive']", + "type": "RuntimeError" + }, + "retry_executions": 0, + "runtime_source_modified_after_failure": false, + "sampled_group_peak_bytes": 19726336, + "schema": "o03-first-fixed-operation-failure-v1", + "secondary_error": "Declared parent readback json.loads rejected GNU time nonzero diagnostic prefix before writing its report", + "source_work_status": "stopped_after_first_fixed_failure", + "wall_seconds_reported": 0.33 +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/I4-PACKET-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/I4-PACKET-v1.json new file mode 100644 index 0000000000..3884b084b4 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/I4-PACKET-v1.json @@ -0,0 +1,28 @@ +{ + "admission": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "command": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "created_utc": "2026-10-31T08:35:25.405240+00:00", + "ledger_reconciliation": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + "original_O03_credit": 0, + "permission": "PARENT_APPROVES_EXACT_FIXED_OPERATION_AFTER_INDEPENDENT_I4_ACCEPT", + "readback": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-COMMAND-v1.json", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + "runtime_operations": 0, + "schema": "o03-exact-parent-I4-proposal-v1", + "source_acceptance": { + "path": "streams/serializer-o03-implementation-20261031/review/COMBINED-SOURCE-REVIEW-v1.json", + "sha256": "f73a19d43ee254b3fdafaaccfa3439ffdda87f84067213a8a39d5393668226d0" + }, + "source_changes": 0 +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LAUNCH-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LAUNCH-v1.json new file mode 100644 index 0000000000..8cc7a2aa15 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LAUNCH-v1.json @@ -0,0 +1,16 @@ +{ + "schema": "o03-exact-parent-launch-v1", + "dispatch_utc": "2026-10-31T08:39:26.821101+00:00", + "review": { + "path": "streams/serializer-o03-implementation-20261031/review/I4-REVIEW-v1.json", + "sha256": "2affb5c91dfe0d41e3b9392b115ff6a135eb1a69d10673b7671bff34d6dc32da" + }, + "command": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "once_only": true, + "runtime_operations": 1, + "no_retry": true, + "status": "DISPATCHING" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LEDGER-001.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LEDGER-001.json new file mode 100644 index 0000000000..54727ec9aa --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LEDGER-001.json @@ -0,0 +1,57 @@ +{ + "I5_I6_I7_qualified": false, + "attempt": 1, + "attempt_policy_seconds": "0.34", + "combined_round_policy_seconds": "94.550533479", + "command_cap_seconds": 180, + "command_tool_result": { + "bytes": 126, + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/EXEC-RESULT-v1.json", + "sha256": "156917ce5281901a1a08ed1c98093e9c9fd361c28cf135863ffe27f4c0e0e01c" + }, + "created_utc": "2026-10-31T08:40:25.505600+00:00", + "full_baseline_candidate_replays": 0, + "guard_status": "STOP", + "historical_gap_preserved": true, + "initial_cap_seconds": 600, + "measured_gain": null, + "no_retry": true, + "observer_record": { + "bytes": 2046, + "path": "streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json", + "sha256": "5258f2c2132f3438497c41116300f52dca6409f021b73025928c84e0b4918652" + }, + "original_goal_credit_added": 0, + "outer_GNU_time": { + "exit": 1, + "kernel_individual_maxrss_kib": 19392, + "system_seconds": 0.06, + "user_seconds": 0.26, + "wall_seconds": 0.33 + }, + "outer_record_interpretation": "Manual bounded accounting parse of preserved GNU time diagnostic line then exact JSON line; not a successful declared parent readback. No rerun or repaired source used.", + "outer_time_raw": { + "bytes": 148, + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json", + "sha256": "a5435c2c21b838555a1c8201831cbab5ccef5c3dd0120972078c86d8a110fdfa" + }, + "parent_readback_status": "FAILED_JSON_PARSE_BEFORE_REPORT", + "parent_readback_tool_result": { + "bytes": 1583, + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-EXEC-RESULT-v1.json", + "sha256": "f3e03d0875879b0dc3316bc1e5b34ea28be8d3c8600587320422c50e222e10cf" + }, + "physical_boundary": "FAILED_ATTEMPT_AND_CONTROLLER_READBACK_REPORT_PUBLICATION_OPEN_NOT_ZERO", + "physical_total_seconds": null, + "prior_ledger": { + "bytes": 1995, + "path": "streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json", + "sha256": "d323469d15edef8ef803ca4241dcd7164010fd77044286220d2ef0d6bf7e15fd" + }, + "prior_policy_seconds": "94.210533479", + "rounding_allowance_seconds": ".01", + "schema": "o03-failed-attempt-canonical-ledger-v1", + "status": "STOP_BEFORE_WORKER_OR_TARGET_IMPORT", + "target_controls_executed": 0, + "total_cap_seconds": 2400 +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LEDGER-RECONCILIATION-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LEDGER-RECONCILIATION-v1.json new file mode 100644 index 0000000000..d8f75fa552 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/LEDGER-RECONCILIATION-v1.json @@ -0,0 +1,78 @@ +{ + "active_canonical_exec_session": null, + "all_other_guarded_work_paused": true, + "chain": [ + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json", + "policy_seconds": "94.210533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-005.json", + "policy_seconds": "90.910533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-004.json", + "policy_seconds": "87.710533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-003.json", + "policy_seconds": "84.450533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-002.json", + "policy_seconds": "80.960533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-001.json", + "policy_seconds": "78.310533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-004.json", + "policy_seconds": "75.750533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-003.json", + "policy_seconds": "73.470533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-002.json", + "policy_seconds": "71.200533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-001.json", + "policy_seconds": "68.630533479", + "status": "PASS" + }, + { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LEDGER-001.json", + "policy_seconds": "66.090533479", + "status": "STOP_BEFORE_COMPONENT_IMPORT" + } + ], + "controller_tail_historical_costs": "OPEN_NOT_ZERO", + "created_utc": "2026-10-31T08:35:25.405240+00:00", + "current_policy_seconds": "94.210533479", + "initial_cap_seconds": 600, + "latest_ledger": { + "path": "streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json", + "sha256": "d323469d15edef8ef803ca4241dcd7164010fd77044286220d2ef0d6bf7e15fd" + }, + "lock": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "new_allowance": false, + "new_round_runtime_operations_before_this": 0, + "physical_total_seconds": null, + "reserved_maximum_seconds": "180", + "schema": "o03-current-ledger-reconciliation-v1", + "scope": "Existing serializer and digest terminal ledgers/round closes plus source-only named-round state; no unclosed new operation exists. Historic physical gaps preserved.", + "total_cap_seconds": 2400, + "upper_after_operation": "274.210533479" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/READBACK-COMMAND-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/READBACK-COMMAND-v1.json new file mode 100644 index 0000000000..a3a2c9a950 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/READBACK-COMMAND-v1.json @@ -0,0 +1,27 @@ +{ + "admission": { + "path": "streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "argv": [ + "/usr/bin/python3.12", + "-B", + "-I", + "-S", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py", + "--admission", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json", + "--admission-sha256", + "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "--observer-record", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json", + "--outer-time", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json", + "--report", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/parent-readback.json" + ], + "command": "/usr/bin/python3.12 -B -I -S /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py --admission /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json --admission-sha256 fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1 --observer-record /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json --outer-time /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json --report /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/parent-readback.json", + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "once_only": true, + "status": "PENDING_INDEPENDENT_I4_REVIEW" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/READBACK-EXEC-RESULT-v1.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/READBACK-EXEC-RESULT-v1.json new file mode 100644 index 0000000000..63f739f57c --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/READBACK-EXEC-RESULT-v1.json @@ -0,0 +1,7 @@ +{ + "chunk_id": "bb73c4", + "wall_time_seconds": 0.000016366, + "exit_code": 1, + "original_token_count": 356, + "output": "Traceback (most recent call last):\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py\", line 62, in \n main()\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py\", line 21, in main\n outer = read_json(Path(args.outer_time))\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py\", line 69, in read_json\n return json.loads(raw)\n ^^^^^^^^^^^^^^^\n File \"/usr/lib/python3.12/json/__init__.py\", line 346, in loads\n return _default_decoder.decode(s)\n ^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/lib/python3.12/json/decoder.py\", line 337, in decode\n obj, end = self.raw_decode(s, idx=_w(s, 0).end())\n ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n File \"/usr/lib/python3.12/json/decoder.py\", line 355, in raw_decode\n raise JSONDecodeError(\"Expecting value\", s, err.value) from None\njson.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)\n" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/complete-fixed-o03-admission.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/complete-fixed-o03-admission.json new file mode 100644 index 0000000000..96d2d36b68 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/complete-fixed-o03-admission.json @@ -0,0 +1,630 @@ +{ + "canonical_ledger": { + "cap_seconds": 2400, + "fresh_files": { + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/control/AGENT-TASK-INDEX-native-fields-v385.json": { + "sha256": "06beb4ec41a750959b3a441f2eaaa3d930680b80f869d5bab643aeb3b393afb5", + "size": 328583 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/control/ROUND-CLOSE-v1.json": { + "sha256": "211a0e5440bbccc404b5113b64d44fe9fc985ef5817a78a4f904a94a714dd82d", + "size": 1844 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-001.json": { + "sha256": "9f00b5b1f8760a9254a8bc93af2f92f93c763e991b0d9daa062f9b27920ed7e4", + "size": 2965 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-002.json": { + "sha256": "525b5c3fb927d947db28ce4aa83e97a249688d68505ad30e3117a22000a7ee78", + "size": 2920 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-003.json": { + "sha256": "d068465be6fc557983031a7a7c9b5f9e1f2670227f72eb1a23dfffe72df8c547", + "size": 2920 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-004.json": { + "sha256": "e5795c9f6640a5ac417c14dcf25255ad39b970b27341638e62b0dcdaa08ca5a4", + "size": 2927 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-005.json": { + "sha256": "0cd8093d3f6de2618a437adc5164416b8fb3190c039491cd184c5a30223f43b3", + "size": 2927 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-006.json": { + "sha256": "e9063e1f1f40b8a97994d3faa4591e1ed0cfa00696dccda505f15ef50026c4a2", + "size": 2920 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-001.json": { + "sha256": "5f727491e2c54925229e74f855ad7b881b5dac8a958474300f1b226b8134ebca", + "size": 2025 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-002.json": { + "sha256": "344cc1cb001843244a7d873c8c95f797cffd19eefd38b84ceab028d283400e9a", + "size": 1995 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-003.json": { + "sha256": "341c6c55ebe45b3f06a7d5f7c57eede4276541f5eca109e53c6ec49707ce6e86", + "size": 1995 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-004.json": { + "sha256": "4e9cfd0d4c29a5bfdc9fc3d0ab33c179329c0b2efa7962ba6e6f2b4b5de50ca8", + "size": 1999 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-005.json": { + "sha256": "ca3c54527ba7a23359dca6873e2ab69245b739c2b577fb6072bf2a954f871d81", + "size": 1999 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json": { + "sha256": "d323469d15edef8ef803ca4241dcd7164010fd77044286220d2ef0d6bf7e15fd", + "size": 1995 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/control/ROUND-CLOSE-v1.json": { + "sha256": "c859ab874ef8f46ffe417b22ed46a6d78ad6d9688bfb5d7113d2a494ff8830de", + "size": 775 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LEDGER-001.json": { + "sha256": "f29bae9908352221e2f6341e137ad39e22899efccaf7151eb1962e9b85447e6b", + "size": 2093 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-001.json": { + "sha256": "18d39ae470e131249a0380bf254d140739c6ddc41e29cd0d29f511bd88312448", + "size": 2954 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-002.json": { + "sha256": "9773784a0a02b08b4f3972fe0e954006d626700093a122ccebfc0ed5d89d3bd3", + "size": 2924 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-003.json": { + "sha256": "79cefa10887c393c80bb78b1038155013605252f81383648920d771bdbb9c500", + "size": 2923 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-004.json": { + "sha256": "8cf5f8b1a1e53436d02cd3be99ffd114f6582433db9b1f6ab19d8ae0ab6bc2e8", + "size": 2982 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/PLAN-v1.md": { + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234", + "size": 6135 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/control/AUTHORIZATION-v1.json": { + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2", + "size": 1169 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json": { + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933", + "size": 4139 + } + }, + "lock_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "spent_seconds": 94.210533479 + }, + "consumed_marker": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-consumed", + "envelope_source_files": { + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py": { + "mode": 292, + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py": { + "mode": 292, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py": { + "mode": 292, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py": { + "mode": 292, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py": { + "mode": 292, + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py": { + "mode": 292, + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py": { + "mode": 292, + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py": { + "mode": 292, + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py": { + "mode": 292, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py": { + "mode": 292, + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + } + }, + "fixed_order": [ + "complete-fixed-o03" + ], + "independent_source_accepted": true, + "input_sources": { + "baseline/evidence/canonical/complex-network.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "size": 5662 + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "size": 22029 + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "size": 16995263 + } + }, + "interpreter": "/usr/bin/python3.12", + "maximum_command_seconds": 180, + "operation": "complete-fixed-o03", + "operation_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03", + "package_sources": { + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583", + "size": 736 + }, + "consumer/CONTROL-SPEC.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423", + "size": 3062 + }, + "consumer/DEPENDENCIES-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69", + "size": 3934 + }, + "consumer/PACKAGE-PINS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PACKAGE-PINS-v1.json", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc", + "size": 2453 + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-ATTEMPTS-v1.json", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875", + "size": 719 + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-CHECKS-v1.json", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381", + "size": 2637 + }, + "consumer/README-v1.md": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/README-v1.md", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7", + "size": 6609 + }, + "consumer/SOURCE-READINESS-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/SOURCE-READINESS-v1.json", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606", + "size": 2081 + }, + "consumer/bounded_serialization.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "size": 23560 + }, + "consumer/full_consumer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688", + "size": 9411 + }, + "consumer/reference.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968", + "size": 2141 + }, + "consumer/run_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf", + "size": 6630 + }, + "consumer/serialization_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "size": 23684 + }, + "consumer/validate_outputs.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e", + "size": 14577 + }, + "envelope/ELF-CLOSURE-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/ELF-CLOSURE-v2.json", + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "size": 8733 + }, + "envelope/FIXED-SEQUENCE-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/FIXED-SEQUENCE-v2.json", + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf", + "size": 5379 + }, + "envelope/RUNTIME-PINS-v2.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "size": 28663 + }, + "envelope/bootstrap.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py", + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "envelope/custody.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "envelope/effective.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "envelope/loader_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "envelope/observer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py", + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "envelope/observer_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py", + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "envelope/observer_fixture.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py", + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "envelope/parent_readback.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py", + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "envelope/sequence_worker.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "envelope/worker.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py", + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + }, + "loader/API-v1.md": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/API-v1.md", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677", + "size": 5012 + }, + "loader/CONTROL-SPEC-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/CONTROL-SPEC-v1.json", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c", + "size": 2002 + }, + "loader/PACKAGE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PACKAGE-PINS-v1.json", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71", + "size": 1152 + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PASSIVE-ATTEMPTS-v1.json", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4", + "size": 586 + }, + "loader/SOURCE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e", + "size": 2395 + }, + "loader/SOURCE-READINESS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-READINESS-v1.json", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f", + "size": 2306 + }, + "loader/frozen_h25_inputs.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a", + "size": 14650 + }, + "loader/frozen_input_controls.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c", + "size": 13181 + }, + "provenance/anchor.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "size": 1926 + }, + "provenance/canonical-MANIFEST.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "size": 1912 + } + }, + "parent_boundary": { + "I7_qualification_still_required": true, + "controller_and_tail": "OPEN_NOT_ZERO", + "fixture_payload_bytes": 117441536, + "initial600_reservation_fits": true, + "no_dispatch_until_independent_I4_acceptance": true, + "no_retry_or_reroll": true + }, + "parent_execution_admitted": true, + "runtime_manifest": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json", + "runtime_sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "sampled_group_cap_bytes": 1073741824, + "schema": "o03-envelope-admission-v1", + "sequence": [ + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}", + "--runtime-manifest", + "{runtime_manifest}", + "--runtime-sha256", + "{runtime_sha256}" + ], + "effective_package_preloads": [], + "entry": "envelope/observer_controls.py", + "id": "observer-controls", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "case_count": 6, + "ordered_cases": [ + "bounded-child-allocation", + "concurrent-parent-child-allocation", + "short-lived-child", + "timeout-kill-reap", + "pid-membership-and-reaped-cleanup", + "sampled-cap-kill-reap" + ], + "status": "PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "count": 39, + "optimize": 0, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 0, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "count": 39, + "optimize": 1, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 1, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--arm", + "baseline", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference" + ], + "entry": "consumer/full_consumer.py", + "id": "baseline-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "baseline", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--arm", + "candidate", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "effective_package_preloads": [ + "frozen_h25_inputs", + "reference", + "bounded_serialization" + ], + "entry": "consumer/full_consumer.py", + "id": "candidate-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "candidate", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--baseline-root", + "{baseline_root}", + "--candidate-root", + "{candidate_root}", + "--baseline-receipt", + "{baseline_receipt}", + "--candidate-receipt", + "{candidate_receipt}", + "--report", + "{receipt}" + ], + "effective_package_preloads": [], + "entry": "consumer/validate_outputs.py", + "id": "independent-validation", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "status": "COMPLETE_OUTPUTS_VALIDATED" + } + } + ], + "worker": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py" +} diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/complete-fixed-o03-consumed b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/complete-fixed-o03-consumed new file mode 100644 index 0000000000..5288e16aca --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/complete-fixed-o03-consumed @@ -0,0 +1 @@ +fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1 diff --git a/research/h25-authentic-serializer-20261031/validation/execution-v1/control/outer-time.json b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/outer-time.json new file mode 100644 index 0000000000..a8b5f46650 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/execution-v1/control/outer-time.json @@ -0,0 +1,2 @@ +Command exited with non-zero status 1 +{"wall_seconds":0.33,"user_seconds":0.26,"system_seconds":0.06,"kernel_individual_maxrss_kib":19392,"exit":1} diff --git a/research/h25-authentic-serializer-20261031/validation/preparation/EVIDENCE-README-v2-before-run.md b/research/h25-authentic-serializer-20261031/validation/preparation/EVIDENCE-README-v2-before-run.md new file mode 100644 index 0000000000..531b2be331 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/preparation/EVIDENCE-README-v2-before-run.md @@ -0,0 +1,13 @@ +# Evidence commit preparation: pending actual fixed operation + +This is an unfrozen local evidence-export skeleton. Do not publish it as a completed runtime outcome. The exact one-run outcome and independent execution/qualification review remain pending and must be added before the final manifest/export freeze and review. + +The first source commit is bc88937088bdd9f4f71fbdc9246dbf58b11eb725. Root README.md, TASK.json, SOURCES.json, SOURCES-EXPORT-v1.json and PACKAGE-MANIFEST-v1.json retain their historical first-source-export meaning and exact bytes. PACKAGE-MANIFEST-v1.json describes its original50 entries excluding itself, not every file added by this later evidence commit. validation/source-publication/EXPORT-FREEZE-v1.json carries the full original51-file tree. A separate versioned final evidence manifest will describe the complete later tree; the original manifests will not be repurposed. + +validation/rejected-envelope-v1/ preserves the exact rejected v1 snapshot and source-reviews/ retains its rejection and supplement. The rejection identified a missing old control-spec dependency and incomplete pre-call effective dependency sealing; the supplement identified the orphan/reaping claim. One permitted source repair produced envelope-revision-v2/, independently accepted by I3-REVIEW-v2.json and COMBINED-SOURCE-REVIEW-v1.json. Original authored readiness files retain their original pending labels; later independent reviews are distinct records and control the accepted-source disposition. + +The copied control-proposal/ is the exact current I4 parent packet at preparation. It is a proposal awaiting independent concrete admission in this skeleton. No operation has been certified or assumed from its presence. The eventual admitted packet, first run, all failure/success/raw receipts, readback, canonical full outer charge and independent outcome/qualification review must be carried without deleting earlier proposals or rejected source history. + +Absolute host source/runtime/interpreter/library/guard paths and runtime metadata are historical identity evidence, not portable clone-and-run instructions. The templates/command records retain exact original bytes. A fresh host/path/runtime requires new complete source/input custody, effective-provider/runtime pins, canonical ledger/lock and exact parent operation admission. The included source repair is not permission to execute it. The source-only feasibility basis is carried under provenance/feasibility/; authentic retained inputs are already included unchanged. + +The finite accepted core boundary and its10ms sampled simultaneous RSS/PID limitations are preserved. Native env/timeout/GNUtime controller instrumentation overhead, initial unsampled observer-import interval, final observer write, parent readback/reconciliation/review/publication and historical/global gaps remain explicit OPEN_NOT_ZERO as specified. No total-guard CPU/RSS, true concurrent peak, actual bounded full-data success, gain or O03 qualification is asserted by this skeleton. No target imports/tests/decoding/native work or remote writes were performed by its author. diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/ADMISSION-TEMPLATE-v1.json b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/ADMISSION-TEMPLATE-v1.json new file mode 100644 index 0000000000..8a9e3d4dfc --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/ADMISSION-TEMPLATE-v1.json @@ -0,0 +1,414 @@ +{ + "canonical_ledger": { + "cap_seconds": 2400, + "fresh_files": { + "PARENT_FILL_EVERY_CANONICAL_LEDGER_POLICY_AND_PRIOR_ATTEMPT_PATH": { + "sha256": "PARENT_FILL", + "size": "PARENT_FILL" + } + }, + "lock_path": "PARENT_FILL_ACTUAL_CANONICAL_LOCK", + "spent_seconds": "PARENT_REFRESH_CANONICAL_NOT_HISTORICAL_94.210533479" + }, + "consumed_marker": "PARENT_FILL_ABSOLUTE_FRESH_CONSUMED_MARKER", + "envelope_source_files": { + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/bootstrap.py": { + "mode": 436, + "sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb", + "size": 7884 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/custody.py": { + "mode": 436, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/effective.py": { + "mode": 436, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/loader_controls.py": { + "mode": 436, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/observer.py": { + "mode": 436, + "sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "size": 14564 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/observer_controls.py": { + "mode": 436, + "sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "size": 3694 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/observer_fixture.py": { + "mode": 436, + "sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0", + "size": 2038 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/sequence_worker.py": { + "mode": 436, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/worker.py": { + "mode": 436, + "sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1", + "size": 6828 + } + }, + "fixed_order": [ + "complete-fixed-o03" + ], + "independent_source_accepted": false, + "input_sources": { + "baseline/evidence/canonical/complex-network.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "size": 5662 + }, + "baseline/evidence/canonical/rank-trace.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "size": 22029 + }, + "baseline/evidence/canonical/witness.json.gz": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "size": 16995263 + } + }, + "interpreter": "/usr/bin/python3.12", + "maximum_command_seconds": 180, + "operation": "complete-fixed-o03", + "operation_root": "PARENT_FILL_ABSOLUTE_FRESH_OPERATION_ROOT", + "package_sources": { + "consumer/bounded_serialization.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "size": 23560 + }, + "consumer/full_consumer.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688", + "size": 9411 + }, + "consumer/reference.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968", + "size": 2141 + }, + "consumer/run_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf", + "size": 6630 + }, + "consumer/serialization_controls.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "size": 23684 + }, + "consumer/validate_outputs.py": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e", + "size": 14577 + }, + "envelope/FIXED-SEQUENCE-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/FIXED-SEQUENCE-v1.json", + "sha256": "e156d8b8600d45b13646f24e46e8e6a3ac05b554c2df81d464447944c0e0095c", + "size": 4529 + }, + "envelope/RUNTIME-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/RUNTIME-PINS-v1.json", + "sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0", + "size": 27394 + }, + "envelope/bootstrap.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/bootstrap.py", + "sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb", + "size": 7884 + }, + "envelope/custody.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "envelope/effective.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "envelope/loader_controls.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "envelope/observer.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/observer.py", + "sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "size": 14564 + }, + "envelope/observer_controls.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/observer_controls.py", + "sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "size": 3694 + }, + "envelope/observer_fixture.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/observer_fixture.py", + "sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0", + "size": 2038 + }, + "envelope/sequence_worker.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "envelope/worker.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/worker.py", + "sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1", + "size": 6828 + }, + "loader/frozen_h25_inputs.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a", + "size": 14650 + }, + "loader/frozen_input_controls.py": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c", + "size": 13181 + }, + "provenance/anchor.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json", + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "size": 1926 + }, + "provenance/canonical-MANIFEST.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json", + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "size": 1912 + }, + "provenance/consumer-DEPENDENCIES-v1.json": { + "mode": 292, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69", + "size": 3934 + }, + "provenance/loader-SOURCE-PINS-v1.json": { + "mode": 436, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e", + "size": 2395 + } + }, + "parent_execution_admitted": false, + "runtime_manifest": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/RUNTIME-PINS-v1.json", + "runtime_sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0", + "sampled_group_cap_bytes": 1073741824, + "schema": "o03-envelope-admission-v1", + "sequence": [ + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}", + "--runtime-manifest", + "{runtime_manifest}", + "--runtime-sha256", + "{runtime_sha256}" + ], + "entry": "envelope/observer_controls.py", + "id": "observer-controls", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "case_count": 6, + "ordered_cases": [ + "bounded-child-allocation", + "concurrent-parent-child-allocation", + "short-lived-child", + "timeout-kill-reap", + "tracked-orphan-cleanup", + "sampled-cap-kill-reap" + ], + "status": "PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "count": 39, + "optimize": 0, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 0, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "count": 39, + "optimize": 1, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 1, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--arm", + "baseline", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/full_consumer.py", + "id": "baseline-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "baseline", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--arm", + "candidate", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/full_consumer.py", + "id": "candidate-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "candidate", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--baseline-root", + "{baseline_root}", + "--candidate-root", + "{candidate_root}", + "--baseline-receipt", + "{baseline_receipt}", + "--candidate-receipt", + "{candidate_receipt}", + "--report", + "{receipt}" + ], + "entry": "consumer/validate_outputs.py", + "id": "independent-validation", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "status": "COMPLETE_OUTPUTS_VALIDATED" + } + } + ], + "worker": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/sequence_worker.py" +} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/FIXED-SEQUENCE-v1.json b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/FIXED-SEQUENCE-v1.json new file mode 100644 index 0000000000..41ccc68d6c --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/FIXED-SEQUENCE-v1.json @@ -0,0 +1,182 @@ +{ + "schema": "o03-fixed-sequence-source-v1", + "sequence": [ + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}", + "--runtime-manifest", + "{runtime_manifest}", + "--runtime-sha256", + "{runtime_sha256}" + ], + "entry": "envelope/observer_controls.py", + "id": "observer-controls", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "case_count": 6, + "ordered_cases": [ + "bounded-child-allocation", + "concurrent-parent-child-allocation", + "short-lived-child", + "timeout-kill-reap", + "tracked-orphan-cleanup", + "sampled-cap-kill-reap" + ], + "status": "PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "count": 39, + "optimize": 0, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-normal", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 0, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 0, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "envelope/loader_controls.py", + "id": "loader-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "count": 39, + "optimize": 1, + "status": "LOADER_CONTROLS_PASS" + } + }, + { + "argv": [ + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/run_controls.py", + "id": "consumer-controls-O", + "must_be_absent_after": [], + "needs_authentic_inputs": false, + "optimization": 1, + "receipt_predicates": { + "new_case_count": 15, + "old_case_count": 70, + "optimization": 1, + "status": "CONSUMER_CONTROLS_RETURNED" + } + }, + { + "argv": [ + "--arm", + "baseline", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/full_consumer.py", + "id": "baseline-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "baseline", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--arm", + "candidate", + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--output-root", + "{output_root}", + "--receipt", + "{receipt}" + ], + "entry": "consumer/full_consumer.py", + "id": "candidate-first", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "arm": "candidate", + "optimization": 0, + "status": "COMPLETE_RETAINED_VALUE_SERIALIZATION_RETURNED" + } + }, + { + "argv": [ + "--input-root", + "{input_root}", + "--custody-json", + "{custody_json}", + "--baseline-root", + "{baseline_root}", + "--candidate-root", + "{candidate_root}", + "--baseline-receipt", + "{baseline_receipt}", + "--candidate-receipt", + "{candidate_receipt}", + "--report", + "{receipt}" + ], + "entry": "consumer/validate_outputs.py", + "id": "independent-validation", + "must_be_absent_after": [], + "needs_authentic_inputs": true, + "optimization": 0, + "receipt_predicates": { + "status": "COMPLETE_OUTPUTS_VALIDATED" + } + } + ] +} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/OPERATION-BILL-v1.json b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/OPERATION-BILL-v1.json new file mode 100644 index 0000000000..d8b08d5d6f --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/OPERATION-BILL-v1.json @@ -0,0 +1,89 @@ +{ + "authentic_input_staging": { + "additional_full_input_hashes": "before/after source and copied-file custody, loader before/after, consumer postcheck, validator independent twice and coordinator custody; all paid", + "bytes_per_copy": 17022954, + "copies": 3, + "copy_read_bytes": 51068862, + "copy_write_bytes": 51068862 + }, + "baseline_writer": { + "encoded_write_hash_bytes_each": 60818421 + }, + "candidate_writer": { + "copy_read_final_write_hash_bytes_each": 60818421, + "private_stage_write_hash_bytes_each": 60818421, + "total_hash_bytes": 121636842, + "total_write_bytes": 121636842 + }, + "controls": { + "all_faults_and_cleanup": "included; first failure stops sequence", + "fixed_timeout_fixture_seconds": 2, + "loader_O": 39, + "loader_normal": 39, + "new_consumer_O": 15, + "new_consumer_normal": 15, + "observer": 6, + "observer_allocation_bytes": 100663296, + "observer_hold_seconds_per_allocation": 0.2, + "old_consumer_O": 70, + "old_consumer_normal": 70 + }, + "each_arm_loader": { + "additional_consumer_transport_rehash_bytes": 17022954, + "gzip_transport_reread_bytes": 17017292, + "local_final_output_read_hash_bytes": 60818421, + "logical_bytes": 60823556, + "plain_certificate_reread_bytes": 5662, + "restoration_and_rank_set": "full genuine witness/result/ranks;59959 events252 rows", + "transport_hash_bytes": 34045908, + "transport_hash_passes_before_after": 2 + }, + "finite_tail": { + "cost": "OPEN_NOT_ZERO", + "final_observer_writes": 1, + "includes": "final observer record and outer-time readback; parent ledger reconciliation/adjudication/publication separately OPEN_NOT_ZERO", + "parent_readback_operations": 1 + }, + "fixed_sequence": [ + "observer-controls", + "loader-controls-normal", + "consumer-controls-normal", + "loader-controls-O", + "consumer-controls-O", + "baseline-first", + "candidate-first", + "independent-validation" + ], + "fresh_budget_seconds": 0, + "guarded_commands": 1, + "historical_setup_seconds": 94.210533479, + "independent_validator": { + "both_output_final_compare_read_bytes": 121636842, + "logical_bytes": 60823556, + "rank_logical_retained_parse_bytes": 2674272, + "result_literal_projection_bytes": 527, + "transport_custody_hash_bytes": 34045908, + "transport_logical_reread_bytes": 17022954 + }, + "measurement": "continuous outer sampled simultaneous parent+descendant RSS; full lifetime SELF+waited-descendant CPU; wrapper GNU time wall/CPU/individual maxRSS; no cgroup peak", + "other_unknown_not_zero": [ + "all actual wall/CPU/peak and sampling missed peaks", + "stdlib tempfile setup filesystem probes", + "source/runtime/metadata/control/failure I/O and repeated hashes", + "physical device/cache traffic", + "historical gaps and whole-goal costs" + ], + "per_command_wall_limit_seconds": 180, + "runtime": "observer+coordinator+8worker+8bootstrap+observer fixtures before/after exact runtime/module/map/callable/effective checks; all repeated hashing/import/metadata/closing work included", + "sampled_rss_cap_bytes": 1073741824, + "schema": "o03-inclusive-complete-operation-bill-v1", + "source_only": true, + "source_package": { + "additional_authentication_reads": "stage source before/after, each copied file hash, complete package snapshot before/after/target bootstrap and fixture checks; all included, never free", + "bytes": 199718, + "files": 23, + "fresh_copies": 8, + "stage_copy_read_and_write_bytes_each_direction": 1597744 + }, + "total_allowance_seconds": 2400 +} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/PASSIVE-CHECKS-v1.json b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/PASSIVE-CHECKS-v1.json new file mode 100644 index 0000000000..5b599edec1 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/PASSIVE-CHECKS-v1.json @@ -0,0 +1,71 @@ +{ + "method": "AST parse and exact named file metadata hashing only", + "process_inspections": 0, + "sources": [ + { + "ast_parse": true, + "mode": 436, + "path": "bootstrap.py", + "sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb", + "size": 7884 + }, + { + "ast_parse": true, + "mode": 436, + "path": "custody.py", + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + { + "ast_parse": true, + "mode": 436, + "path": "effective.py", + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + { + "ast_parse": true, + "mode": 436, + "path": "loader_controls.py", + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + { + "ast_parse": true, + "mode": 436, + "path": "observer.py", + "sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "size": 14564 + }, + { + "ast_parse": true, + "mode": 436, + "path": "observer_controls.py", + "sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "size": 3694 + }, + { + "ast_parse": true, + "mode": 436, + "path": "observer_fixture.py", + "sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0", + "size": 2038 + }, + { + "ast_parse": true, + "mode": 436, + "path": "sequence_worker.py", + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + { + "ast_parse": true, + "mode": 436, + "path": "worker.py", + "sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1", + "size": 6828 + } + ], + "target_executions": 0, + "tests_controls_benchmarks": 0 +} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/README-v1.md b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/README-v1.md new file mode 100644 index 0000000000..79d96219d5 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/README-v1.md @@ -0,0 +1,27 @@ +# Fixed O03 execution source + +SOURCE ONLY. No control, target import, staging, decode, process inspection or benchmark has been executed here. The independently accepted I1/I2 loader/consumer sources are dependencies. This packet requests I3 source review only; it grants no execution or O03 credit. + +The only proposed operation is `complete-fixed-o03`: six observer controls;39 loader cases normal;70 original+15 consumer cases normal;39 loader cases -O;70 original+15 consumer cases -O; first optimization0 baseline; first optimization0 candidate; separate independent full validator. The source order is FIXED-SEQUENCE-v1.json. All eight children are serial and reaped; every command belongs to one inclusive <=180-second guarded operation. No adaptive split, retry, reroll or smaller data substitute is authorized. Cap failure preserves this first attempt. Source-reviewed separate-stage use would require new explicit parent admission, not silent fallback. + +Parent fills ADMISSION-TEMPLATE-v1.json only after independent source acceptance and refreshed canonical ledger admission. Replace its administrative placeholders with exact absolute fresh paths/ledger hashes, preserve the entire source-frozen `sequence`, source/input pins, interpreter and caps, and independently anchor the final admission SHA256. Set both acceptance booleans true only after their respective approvals. `canonical_ledger.fresh_files` must cover every actual ledger/policy/prior-attempt record needed to establish current spent seconds, including incomplete attempts; `lock_path` must be the actual existing canonical writer lock used by all other guarded work. The observer takes that same nonblocking exclusive lock. Parent must stop other work, reconcile any unclosed prior attempt first, and add this observer receipt's full policy charge to the canonical ledger before any future operation. No alternate local allowance is created;94.210533479 is only the setup historical value. + +Exact command shape (all paths absolute and the digest filled from the final independently admitted metadata): + +``` +/usr/bin/timeout --signal=TERM --kill-after=1s 179s /usr/bin/time -f '{"wall_seconds":%e,"user_seconds":%U,"system_seconds":%S,"kernel_individual_maxrss_kib":%M,"exit":%x}' -o ABSOLUTE_PARENT_CONTROL_PATH/outer-time.json -- /usr/bin/python3.12 -B -I -S ABSOLUTE_ENVELOPE_PATH/observer.py --admission ABSOLUTE_PARENT_CONTROL_PATH/complete-fixed-o03-admission.json --admission-sha256 EXACT_ADMITTED_SHA256 +``` + +The outer timeout is a179s deadline with a final1s kill bound, never a budget extension. The inclusive observer begins its first-instruction timer before other imports, starts a continuous parent/descendant sampler before admission/source/runtime authentication and keeps it through all substantive closing readbacks. Runtime package/input staging, import verification, tempfile initialization, controls, complete baseline/candidate, complete independent validation, receipts, logs, success/failure cleanup checks and source/input/runtime reauthentication occur inside. Python interpreter startup before the first instruction is measured by outer GNU time, whose entire fresh observer+descendants CPU is also separately retained. `/usr/bin/time` maxRSS is an individual-process high water mark and never a simultaneous aggregate memory peak. + +The observer reports simultaneous sampled RSS for its parent and discoverable descendants,10ms interval, PID/start-time identities and missed-short-process/peak/reparenting limitations. It tracks known identities after reparenting, rejects live survivors and kills/reaps the direct child on timeout/cap/signal. Zero-RSS orphan zombies awaiting init are recorded as a membership limitation, not live work. No cgroup peak or exact true peak is claimed. Observer controls exercise child allocation, simultaneous parent/child/grandchild allocation, a short child, timeout+kill/reap, a tracked orphan and memory-cap kill/reap. Each fixture authenticates runtime before/after; the allocation controls do not substitute for genuine serialization. + +All initial source/bootstrap import windows before the observer sampler's first sample are exposed as sampling limitations. GNU time captures whole-process startup CPU/wall and kernel individual maxRSS. This is not an exact concurrent-RSS guarantee during unsampled windows. No source metadata is presented as target runtime admission. + +Runtime policy is explicitly `-B -I -S` for observer, coordinator, arms and fixture descendants: no system-site/.pth execution. RUNTIME-PINS-v1.json retains a conservative exact file/module allowlist from the accepted digest runtime plus named gzip/struct/ASCII/Latin1/locale files; every actual file-backed module/map must be pinned. There is no imaginary zlib extension: actual builtin zlib membership/origin and gzip provider identity must match the pinned interpreter, and actual linked libz1.3 must occur in maps. Actual _json scanner/encoder and _hashlib OpenSSL SHA256 bindings are checked. Builtin math/fcntl/select/_struct/_posixsubprocess/marshal are checked against actual sys.builtin_module_names. Any different binding fails the fixed attempt, without unmeasured discovery or patching the manifest from a lucky run. + +Before any target import all prospective runtime files and complete fresh package are authenticated. Each entry is imported by exact source location under fixed `o03_entry`, effective bindings are frozen, and its reviewed main is called once. Validator import isolation is preserved: its process imports no loader, reference or candidate. Effective fingerprints retain callable identity/code/defaults/closures, referenced callable/class globals, builtin identities, module uppercase constants and all own class slots/properties/static/class methods; they reject surviving method/function/global rebinding. Paid source-bound tempfile.gettempdir/_get_candidate_names initialization precedes sealing to prevent legitimate lazy global changes. `/tmp` is required. Mutable cache content is not frozen. Trusted local CPython/import machinery and no hostile concurrent host mutation remain explicit finite-environment assumptions; cached bytecode is not independently attested by source hashes, matching the predecessor runtime's stated assumption. + +The three input transports are copied afresh into separately owned0444 regular nlink1 files, with every input directory/root0555. Loader custody contains exactly the original three transport paths and fresh root/directory/file identities; canonical MANIFEST and anchor are separately copied into sealed package provenance. Neither original mirror modes nor matching bytes alone establish old custody. Fresh full custody checks run before/after. The consumed marker is created before substantive work; every failure is retained. Immutable staged inputs/packages and final evidence are intentionally retained, while candidate private stage cleanup is independently validated. + +The finite closing boundary has one final observer-record write and one parent readback of that record plus outer-time metadata; their known/unknown cost remains OPEN_NOT_ZERO. Parent canonical-ledger reconciliation, independent evidence adjudication, publication and historic physical gaps also remain OPEN_NOT_ZERO. No substantive serializer/control/validation/cleanup/readback is moved into this tail. P5 observer/runtime/source validation inside the operation is distinct from later independent scientific qualification. An absent/incomplete observer/time record is failure evidence requiring reconciliation, never a zero-cost attempt. diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/RUNTIME-PINS-v1.json b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/RUNTIME-PINS-v1.json new file mode 100644 index 0000000000..aeafd6b9d7 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/RUNTIME-PINS-v1.json @@ -0,0 +1,709 @@ +{ + "assumptions": [ + "Trusted local CPython/Linux finite host; no hostile concurrent loader/host mutation.", + "Source metadata verified now; actual module origins/builtin membership/maps/callables are prospective and must pass guarded before/after checks. No target/helper/process inspection performed during source preparation.", + "Interpreter reads of cached bytecode remain an explicit trusted-host import-machinery assumption inherited from accepted predecessor; source hashes alone are not bytecode attestation.", + "Package entry imported via fixed source location then reviewed main called once; all package/input copies fresh and sealed.", + "Effective before/after fingerprints include callable identities, Python code, defaults/closures, referenced global callable/class identities, builtin authority and own class slots; mutable cache contents are outside frozen state.", + "Paid source-bound setup initializes tempfile.gettempdir and _get_candidate_names before effective seal; require /tmp. This prevents legitimate lazy global rebinding falsely rejecting first candidate/control.", + "Prospective selected callable descriptors and actual builtin membership/maps must pass the first admitted fixed operation. No runtime probe was performed." + ], + "builtin_zlib_provider": "/usr/bin/python3.12", + "callable_bindings": { + "_hashlib.openssl_sha256": { + "module": "_hashlib", + "qualname": "openssl_sha256", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + }, + "_json.make_encoder": { + "module": "_json", + "qualname": "Encoder", + "type_module": "builtins", + "type_name": "type" + }, + "_json.make_scanner": { + "module": "_json", + "qualname": "Scanner", + "type_module": "builtins", + "type_name": "type" + }, + "gzip.GzipFile": { + "module": "gzip", + "qualname": "GzipFile", + "type_module": "builtins", + "type_name": "type" + }, + "hashlib.sha256": { + "module": "_hashlib", + "qualname": "openssl_sha256", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + }, + "json.dumps": { + "module": "json", + "qualname": "dumps", + "type_module": "builtins", + "type_name": "function" + }, + "json.loads": { + "module": "json", + "qualname": "loads", + "type_module": "builtins", + "type_name": "function" + }, + "zlib.crc32": { + "module": "zlib", + "qualname": "crc32", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + }, + "zlib.decompressobj": { + "module": "zlib", + "qualname": "decompressobj", + "type_module": "builtins", + "type_name": "builtin_function_or_method" + } + }, + "executable": "/usr/bin/python3.12", + "files": { + "/etc/python3.12/sitecustomize.py": { + "mode": 420, + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e", + "size": 155 + }, + "/usr/bin/python3.12": { + "mode": 493, + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f", + "size": 8020928 + }, + "/usr/bin/time": { + "mode": 493, + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10", + "size": 27160 + }, + "/usr/bin/timeout": { + "mode": 493, + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52", + "size": 39880 + }, + "/usr/lib/locale/C.utf8/LC_CTYPE": { + "mode": 420, + "sha256": "59015993b1b671273461ef1167d7a9ad76dc090d521c91102e962217ed6b6dba", + "size": 360460 + }, + "/usr/lib/python3.12/__future__.py": { + "mode": 420, + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c", + "size": 5218 + }, + "/usr/lib/python3.12/_collections_abc.py": { + "mode": 420, + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6", + "size": 32082 + }, + "/usr/lib/python3.12/_compression.py": { + "mode": 420, + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981", + "size": 5681 + }, + "/usr/lib/python3.12/_sitebuiltins.py": { + "mode": 420, + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc", + "size": 3128 + }, + "/usr/lib/python3.12/_weakrefset.py": { + "mode": 420, + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac", + "size": 5893 + }, + "/usr/lib/python3.12/abc.py": { + "mode": 420, + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287", + "size": 6538 + }, + "/usr/lib/python3.12/argparse.py": { + "mode": 420, + "sha256": "29395feb61bc376ca4ff9d44069af8d914ec2a1f25a4bd7978f6e2afef5bc07f", + "size": 101750 + }, + "/usr/lib/python3.12/ast.py": { + "mode": 420, + "sha256": "d16626aa5c054bcc45221e56f84e55051b046caf0f8be1fe4902ea71534fb735", + "size": 64260 + }, + "/usr/lib/python3.12/bisect.py": { + "mode": 420, + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999", + "size": 3423 + }, + "/usr/lib/python3.12/bz2.py": { + "mode": 420, + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330", + "size": 11847 + }, + "/usr/lib/python3.12/codecs.py": { + "mode": 420, + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785", + "size": 36870 + }, + "/usr/lib/python3.12/collections/__init__.py": { + "mode": 420, + "sha256": "0af967cd58036507b3d0fbc33b7a996c61dbb52a94b0b738c8bef12cd4cc7dd4", + "size": 52378 + }, + "/usr/lib/python3.12/collections/abc.py": { + "mode": 420, + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10", + "size": 119 + }, + "/usr/lib/python3.12/contextlib.py": { + "mode": 420, + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6", + "size": 27637 + }, + "/usr/lib/python3.12/copy.py": { + "mode": 420, + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab", + "size": 8412 + }, + "/usr/lib/python3.12/copyreg.py": { + "mode": 420, + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9", + "size": 7614 + }, + "/usr/lib/python3.12/datetime.py": { + "mode": 420, + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238", + "size": 268 + }, + "/usr/lib/python3.12/encodings/__init__.py": { + "mode": 420, + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8", + "size": 5884 + }, + "/usr/lib/python3.12/encodings/aliases.py": { + "mode": 420, + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2", + "size": 15677 + }, + "/usr/lib/python3.12/encodings/ascii.py": { + "mode": 420, + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3", + "size": 1248 + }, + "/usr/lib/python3.12/encodings/latin_1.py": { + "mode": 420, + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c", + "size": 1264 + }, + "/usr/lib/python3.12/encodings/utf_8.py": { + "mode": 420, + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d", + "size": 1005 + }, + "/usr/lib/python3.12/enum.py": { + "mode": 420, + "sha256": "c8ead615c159598370295649eb296819ad4b40d50b200c4fec2d4269bf7af9ae", + "size": 81636 + }, + "/usr/lib/python3.12/fnmatch.py": { + "mode": 420, + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc", + "size": 5999 + }, + "/usr/lib/python3.12/functools.py": { + "mode": 420, + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033", + "size": 38126 + }, + "/usr/lib/python3.12/genericpath.py": { + "mode": 420, + "sha256": "2b0b35d2206778af4081cf81dd9b513876e72c35a55bec941402e1fa62b1f1aa", + "size": 5572 + }, + "/usr/lib/python3.12/gettext.py": { + "mode": 420, + "sha256": "1cc6fd33bdce3bb29c0c37ec9a2f5bf15a315e9776b329247e6675c028a8af39", + "size": 21747 + }, + "/usr/lib/python3.12/gzip.py": { + "mode": 420, + "sha256": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5", + "size": 24859 + }, + "/usr/lib/python3.12/hashlib.py": { + "mode": 420, + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab", + "size": 9349 + }, + "/usr/lib/python3.12/importlib/__init__.py": { + "mode": 420, + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730", + "size": 4774 + }, + "/usr/lib/python3.12/importlib/_abc.py": { + "mode": 420, + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8", + "size": 1354 + }, + "/usr/lib/python3.12/importlib/_bootstrap.py": { + "mode": 420, + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed", + "size": 57056 + }, + "/usr/lib/python3.12/importlib/_bootstrap_external.py": { + "mode": 420, + "sha256": "97c6211750d63067712ad2cd74d50be33337f1fb1cd2c769022ced9b401edd92", + "size": 69197 + }, + "/usr/lib/python3.12/importlib/machinery.py": { + "mode": 420, + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede", + "size": 880 + }, + "/usr/lib/python3.12/importlib/util.py": { + "mode": 420, + "sha256": "ca54e6458dbe521d591e5b8d9bb651ef929bfae946706c98470cdd569041a64f", + "size": 10840 + }, + "/usr/lib/python3.12/io.py": { + "mode": 420, + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822", + "size": 3582 + }, + "/usr/lib/python3.12/ipaddress.py": { + "mode": 420, + "sha256": "cc9831e239bd81c1480a12733bded744002d93815fd0d083c77aea348c956e67", + "size": 78294 + }, + "/usr/lib/python3.12/json/__init__.py": { + "mode": 420, + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5", + "size": 14020 + }, + "/usr/lib/python3.12/json/decoder.py": { + "mode": 420, + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b", + "size": 12473 + }, + "/usr/lib/python3.12/json/encoder.py": { + "mode": 420, + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869", + "size": 16070 + }, + "/usr/lib/python3.12/json/scanner.py": { + "mode": 420, + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08", + "size": 2425 + }, + "/usr/lib/python3.12/keyword.py": { + "mode": 420, + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b", + "size": 1073 + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76", + "size": 32112 + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe", + "size": 64368 + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3", + "size": 48952 + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7", + "size": 49256 + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "mode": 420, + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907", + "size": 19432 + }, + "/usr/lib/python3.12/locale.py": { + "mode": 420, + "sha256": "d1134b7212bad37b7b81339061dc37a19a194aa183ec2cb60412cf365993b151", + "size": 78562 + }, + "/usr/lib/python3.12/lzma.py": { + "mode": 420, + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e", + "size": 13277 + }, + "/usr/lib/python3.12/ntpath.py": { + "mode": 420, + "sha256": "c4dd79bf103677daaad873952b89fc1f973425e7b250006cc35af4c164181da8", + "size": 30027 + }, + "/usr/lib/python3.12/operator.py": { + "mode": 420, + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a", + "size": 10965 + }, + "/usr/lib/python3.12/os.py": { + "mode": 420, + "sha256": "316d1b7307fd851bded3423c9d437e0a383c725d993f0fcff2e8b749fe560b62", + "size": 39786 + }, + "/usr/lib/python3.12/pathlib.py": { + "mode": 420, + "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d", + "size": 51153 + }, + "/usr/lib/python3.12/platform.py": { + "mode": 493, + "sha256": "ed0defe8ff7c116710493ffd099b566d3de686ab1b431a3d5401056798e59341", + "size": 43331 + }, + "/usr/lib/python3.12/posixpath.py": { + "mode": 420, + "sha256": "c443d7b8afad1717e7060ce49b3e04423058de56cd4246ee6bcc1ac962eb5c2b", + "size": 17623 + }, + "/usr/lib/python3.12/random.py": { + "mode": 420, + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425", + "size": 34683 + }, + "/usr/lib/python3.12/re/__init__.py": { + "mode": 420, + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b", + "size": 16315 + }, + "/usr/lib/python3.12/re/_casefix.py": { + "mode": 420, + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40", + "size": 5446 + }, + "/usr/lib/python3.12/re/_compiler.py": { + "mode": 420, + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a", + "size": 26089 + }, + "/usr/lib/python3.12/re/_constants.py": { + "mode": 420, + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375", + "size": 5930 + }, + "/usr/lib/python3.12/re/_parser.py": { + "mode": 420, + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840", + "size": 41201 + }, + "/usr/lib/python3.12/reprlib.py": { + "mode": 420, + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015", + "size": 6569 + }, + "/usr/lib/python3.12/selectors.py": { + "mode": 420, + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385", + "size": 19671 + }, + "/usr/lib/python3.12/shutil.py": { + "mode": 420, + "sha256": "819e518cb7a539d09b2526138015541b34d2646afb9c2f6ae4ffd476d6a0fcf4", + "size": 58120 + }, + "/usr/lib/python3.12/signal.py": { + "mode": 420, + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a", + "size": 2495 + }, + "/usr/lib/python3.12/site.py": { + "mode": 420, + "sha256": "619436355cbe91c3b29681ab486ee63f5f2e0a7d6274dfae747bdb94e60bca55", + "size": 23903 + }, + "/usr/lib/python3.12/stat.py": { + "mode": 420, + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77", + "size": 5485 + }, + "/usr/lib/python3.12/struct.py": { + "mode": 420, + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856", + "size": 257 + }, + "/usr/lib/python3.12/subprocess.py": { + "mode": 420, + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9", + "size": 88725 + }, + "/usr/lib/python3.12/tempfile.py": { + "mode": 420, + "sha256": "8c8033ed1426ace79e07a6608887d2a1694d817d63d61b04c3d59339f24b4269", + "size": 37334 + }, + "/usr/lib/python3.12/threading.py": { + "mode": 420, + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b", + "size": 60123 + }, + "/usr/lib/python3.12/types.py": { + "mode": 420, + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405", + "size": 10993 + }, + "/usr/lib/python3.12/urllib/__init__.py": { + "mode": 420, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "size": 0 + }, + "/usr/lib/python3.12/urllib/parse.py": { + "mode": 420, + "sha256": "a67b5694763137dbac085adbf0c22821d435ec8ca22d3bd3786d2c9f4ee748d5", + "size": 45591 + }, + "/usr/lib/python3.12/warnings.py": { + "mode": 420, + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49", + "size": 21760 + }, + "/usr/lib/python3.12/weakref.py": { + "mode": 420, + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c", + "size": 21513 + }, + "/usr/lib/python3.12/zipimport.py": { + "mode": 420, + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0", + "size": 28132 + }, + "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py": { + "mode": 420, + "sha256": "46849a60a7cc85189cf6b5ac62b3f135004862ce6a96540a81c95ef6fbc4dc3e", + "size": 6299 + }, + "/usr/lib/python3/dist-packages/apport_python_hook.py": { + "mode": 420, + "sha256": "2aac4de740babcc6038483cccc7fa71f7f06405da9b9d102aafe8ac55f509c4b", + "size": 8695 + }, + "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py": { + "mode": 420, + "sha256": "c38b82e5f241e83edbbe9bcfdcb8747f11071b32fbc8b7c950e38260a0059edb", + "size": 122 + }, + "/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache": { + "mode": 420, + "sha256": "52c227df9d53248238602c1ddaccd2c8ddc4cc6a61aa45d7c425af590b8806a5", + "size": 27028 + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "mode": 493, + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da", + "size": 236616 + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "mode": 420, + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1", + "size": 78944 + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "mode": 493, + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf", + "size": 2129424 + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "mode": 420, + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a", + "size": 5309400 + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "mode": 420, + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d", + "size": 186624 + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "mode": 420, + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d", + "size": 202904 + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "mode": 420, + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0", + "size": 952616 + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "mode": 420, + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242", + "size": 113000 + } + }, + "linked_libz": "/usr/lib/x86_64-linux-gnu/libz.so.1.3", + "mapped_files": [ + "/usr/bin/python3.12", + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4", + "/usr/lib/x86_64-linux-gnu/libc.so.6", + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3", + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1", + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5", + "/usr/lib/x86_64-linux-gnu/libm.so.6", + "/usr/lib/x86_64-linux-gnu/libz.so.1.3", + "/usr/lib/locale/C.utf8/LC_CTYPE", + "/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache" + ], + "module_paths": { + "__future__": "/usr/lib/python3.12/__future__.py", + "_bz2": "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so", + "_collections_abc": "/usr/lib/python3.12/_collections_abc.py", + "_compression": "/usr/lib/python3.12/_compression.py", + "_distutils_hack": "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py", + "_frozen_importlib": "/usr/lib/python3.12/importlib/_bootstrap.py", + "_frozen_importlib_external": "/usr/lib/python3.12/importlib/_bootstrap_external.py", + "_hashlib": "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so", + "_json": "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so", + "_lzma": "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so", + "_sitebuiltins": "/usr/lib/python3.12/_sitebuiltins.py", + "_weakrefset": "/usr/lib/python3.12/_weakrefset.py", + "abc": "/usr/lib/python3.12/abc.py", + "apport_python_hook": "/usr/lib/python3/dist-packages/apport_python_hook.py", + "argparse": "/usr/lib/python3.12/argparse.py", + "ast": "/usr/lib/python3.12/ast.py", + "bisect": "/usr/lib/python3.12/bisect.py", + "bz2": "/usr/lib/python3.12/bz2.py", + "codecs": "/usr/lib/python3.12/codecs.py", + "collections": "/usr/lib/python3.12/collections/__init__.py", + "collections.abc": "/usr/lib/python3.12/collections/abc.py", + "contextlib": "/usr/lib/python3.12/contextlib.py", + "copy": "/usr/lib/python3.12/copy.py", + "copyreg": "/usr/lib/python3.12/copyreg.py", + "datetime": "/usr/lib/python3.12/datetime.py", + "encodings": "/usr/lib/python3.12/encodings/__init__.py", + "encodings.aliases": "/usr/lib/python3.12/encodings/aliases.py", + "encodings.ascii": "/usr/lib/python3.12/encodings/ascii.py", + "encodings.latin_1": "/usr/lib/python3.12/encodings/latin_1.py", + "encodings.utf_8": "/usr/lib/python3.12/encodings/utf_8.py", + "enum": "/usr/lib/python3.12/enum.py", + "fnmatch": "/usr/lib/python3.12/fnmatch.py", + "functools": "/usr/lib/python3.12/functools.py", + "genericpath": "/usr/lib/python3.12/genericpath.py", + "gettext": "/usr/lib/python3.12/gettext.py", + "gzip": "/usr/lib/python3.12/gzip.py", + "hashlib": "/usr/lib/python3.12/hashlib.py", + "importlib": "/usr/lib/python3.12/importlib/__init__.py", + "importlib._abc": "/usr/lib/python3.12/importlib/_abc.py", + "importlib._bootstrap": "/usr/lib/python3.12/importlib/_bootstrap.py", + "importlib._bootstrap_external": "/usr/lib/python3.12/importlib/_bootstrap_external.py", + "importlib.machinery": "/usr/lib/python3.12/importlib/machinery.py", + "importlib.util": "/usr/lib/python3.12/importlib/util.py", + "io": "/usr/lib/python3.12/io.py", + "ipaddress": "/usr/lib/python3.12/ipaddress.py", + "json": "/usr/lib/python3.12/json/__init__.py", + "json.decoder": "/usr/lib/python3.12/json/decoder.py", + "json.encoder": "/usr/lib/python3.12/json/encoder.py", + "json.scanner": "/usr/lib/python3.12/json/scanner.py", + "keyword": "/usr/lib/python3.12/keyword.py", + "locale": "/usr/lib/python3.12/locale.py", + "lzma": "/usr/lib/python3.12/lzma.py", + "mpl_toolkits": "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py", + "ntpath": "/usr/lib/python3.12/ntpath.py", + "operator": "/usr/lib/python3.12/operator.py", + "os": "/usr/lib/python3.12/os.py", + "os.path": "/usr/lib/python3.12/posixpath.py", + "pathlib": "/usr/lib/python3.12/pathlib.py", + "platform": "/usr/lib/python3.12/platform.py", + "posixpath": "/usr/lib/python3.12/posixpath.py", + "random": "/usr/lib/python3.12/random.py", + "re": "/usr/lib/python3.12/re/__init__.py", + "re._casefix": "/usr/lib/python3.12/re/_casefix.py", + "re._compiler": "/usr/lib/python3.12/re/_compiler.py", + "re._constants": "/usr/lib/python3.12/re/_constants.py", + "re._parser": "/usr/lib/python3.12/re/_parser.py", + "reprlib": "/usr/lib/python3.12/reprlib.py", + "resource": "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so", + "selectors": "/usr/lib/python3.12/selectors.py", + "shutil": "/usr/lib/python3.12/shutil.py", + "signal": "/usr/lib/python3.12/signal.py", + "site": "/usr/lib/python3.12/site.py", + "sitecustomize": "/etc/python3.12/sitecustomize.py", + "stat": "/usr/lib/python3.12/stat.py", + "struct": "/usr/lib/python3.12/struct.py", + "subprocess": "/usr/lib/python3.12/subprocess.py", + "tempfile": "/usr/lib/python3.12/tempfile.py", + "threading": "/usr/lib/python3.12/threading.py", + "types": "/usr/lib/python3.12/types.py", + "urllib": "/usr/lib/python3.12/urllib/__init__.py", + "urllib.parse": "/usr/lib/python3.12/urllib/parse.py", + "warnings": "/usr/lib/python3.12/warnings.py", + "weakref": "/usr/lib/python3.12/weakref.py", + "zipimport": "/usr/lib/python3.12/zipimport.py" + }, + "package_modules": { + "bootstrap": "envelope/bootstrap.py", + "bounded_serialization": "consumer/bounded_serialization.py", + "custody": "envelope/custody.py", + "effective": "envelope/effective.py", + "frozen_h25_inputs": "loader/frozen_h25_inputs.py", + "frozen_input_controls": "loader/frozen_input_controls.py", + "full_consumer": "consumer/full_consumer.py", + "loader_controls": "envelope/loader_controls.py", + "observer": "envelope/observer.py", + "observer_controls": "envelope/observer_controls.py", + "observer_fixture": "envelope/observer_fixture.py", + "reference": "consumer/reference.py", + "run_controls": "consumer/run_controls.py", + "sequence_worker": "envelope/sequence_worker.py", + "serialization_controls": "consumer/serialization_controls.py", + "validate_outputs": "consumer/validate_outputs.py", + "worker": "envelope/worker.py" + }, + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/stages/inventory-v1/RUNTIME-PINS.json", + "sha256": "ad2655b40ae2340048526a02d9a4215341112ef27f565c32a7ea5a87e80a0061" + }, + "preload_modules": [ + "argparse", + "copy", + "contextlib", + "gzip", + "hashlib", + "importlib.util", + "json", + "json.encoder", + "math", + "os", + "pathlib", + "stat", + "sys", + "time", + "types", + "tempfile", + "shutil", + "threading", + "resource", + "fcntl", + "subprocess", + "marshal", + "_json", + "_hashlib" + ], + "python_version": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "remaining_guarded_acquisition": "No unmeasured discovery probe. First admitted observer-controls attempt performs exact required builtin/origin/map/selected-binding checks and fails closed on mismatch; never amend from success/failure without new independent review and consumed-operation disposition.", + "required_builtin_modules": [ + "zlib", + "math", + "fcntl", + "select", + "_struct", + "_posixsubprocess", + "marshal" + ], + "schema": "o03-prospective-runtime-pins-v1", + "site_policy": "-B -I -S for every process; actual flags.no_site=1 required; site/.pth not executed.", + "status": "SOURCE_METADATA_ONLY_NOT_RUNTIME_ADMISSION" +} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/RUNTIME-PINS-v1.sha256 b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/RUNTIME-PINS-v1.sha256 new file mode 100644 index 0000000000..6bdbafa683 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/RUNTIME-PINS-v1.sha256 @@ -0,0 +1 @@ +5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0 diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/SOURCE-READINESS-v1.json b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/SOURCE-READINESS-v1.json new file mode 100644 index 0000000000..51004ecdf6 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/SOURCE-READINESS-v1.json @@ -0,0 +1,99 @@ +{ + "I3_independently_accepted": false, + "controls": 6, + "entry": "observer.py -> sequence_worker.py -> worker.py -> bootstrap.py -> exact reviewed entry.main", + "files": { + "ADMISSION-TEMPLATE-v1.json": { + "mode": 436, + "sha256": "30cb1f9d8ba4fb886a43793bf783f3fcdf69fa98cc658ee42eaacb26424825fe", + "size": 18528 + }, + "FIXED-SEQUENCE-v1.json": { + "mode": 436, + "sha256": "e156d8b8600d45b13646f24e46e8e6a3ac05b554c2df81d464447944c0e0095c", + "size": 4529 + }, + "OPERATION-BILL-v1.json": { + "mode": 436, + "sha256": "e7b0e21fdc01dc350ca5f71eb84757ae37161b527ea8eef82b14c63d9c79f97c", + "size": 3577 + }, + "PASSIVE-CHECKS-v1.json": { + "mode": 436, + "sha256": "e8a7c60e568ef9ea57b9ae612145d46dbd372aae9d053eedb4c034d2864a725e", + "size": 1909 + }, + "README-v1.md": { + "mode": 436, + "sha256": "c5337759f784b15e5a45a937ce12e767aea23ed86b1e901efc79da0cbac06d84", + "size": 7602 + }, + "RUNTIME-PINS-v1.json": { + "mode": 436, + "sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0", + "size": 27394 + }, + "RUNTIME-PINS-v1.sha256": { + "mode": 436, + "sha256": "067af3eb524cc3ea7a8389bac3ff93e50e14159565521977d7bede26f055ef42", + "size": 65 + }, + "bootstrap.py": { + "mode": 436, + "sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb", + "size": 7884 + }, + "custody.py": { + "mode": 436, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "effective.py": { + "mode": 436, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "loader_controls.py": { + "mode": 436, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "observer.py": { + "mode": 436, + "sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "size": 14564 + }, + "observer_controls.py": { + "mode": 436, + "sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "size": 3694 + }, + "observer_fixture.py": { + "mode": 436, + "sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0", + "size": 2038 + }, + "sequence_worker.py": { + "mode": 436, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "worker.py": { + "mode": 436, + "sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1", + "size": 6828 + } + }, + "guarded_execution_admitted": false, + "remaining_parent_work": [ + "Independent I3 review exact frozen source and finite boundary", + "Refresh complete canonical ledger and fill exact admission placeholders; seal command/runtime/source/input identities", + "Admit the single fixed inclusive180s operation or retain NO_GO if resource fit/source boundary is not accepted", + "First operation performs actual runtime checks; no separate unmeasured discovery/probe", + "One parent readback; canonical charging, independent P5/adjudication and publication remain explicit OPEN_NOT_ZERO" + ], + "runtime_sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0", + "schema": "o03-I3-source-readiness-v1", + "source_execution_count": 0, + "status": "AUTHORED_SOURCE_ONLY_PENDING_INDEPENDENT_REVIEW" +} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/bootstrap.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/bootstrap.py new file mode 100644 index 0000000000..075fad92cd --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/bootstrap.py @@ -0,0 +1,151 @@ +"""Run a fixed target in the same interpreter as effective runtime checks. + +This module is entered only from the inclusive observer. All imports and checks +here are inside that boundary. Runtime manifests are independently frozen, never +learned from a successful target or amended after a failure. +""" +import sys +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import gzip +import hashlib +import importlib +import json +import os +from effective import capture, unchanged +import zlib +from custody import check_snapshot, need, pin, read_json, safe, same, write_json + + +def mappings(): + paths = set() + for line in Path('/proc/self/maps').read_text().splitlines(): + row = line.split(maxsplit=5) + if len(row) == 6 and row[5].startswith('/'): + need(not row[5].endswith(' (deleted)'), 'deleted runtime mapping') + paths.add(str(Path(row[5]).resolve())) + return paths + + +def callable_bindings(): + import _json + import _hashlib + selected = {'gzip.GzipFile': gzip.GzipFile, 'zlib.decompressobj': zlib.decompressobj, + 'zlib.crc32': zlib.crc32, 'json.loads': json.loads, 'json.dumps': json.dumps, + '_json.make_scanner': _json.make_scanner, '_json.make_encoder': _json.make_encoder, + 'hashlib.sha256': hashlib.sha256, '_hashlib.openssl_sha256': _hashlib.openssl_sha256} + names = {name: {'module': getattr(obj, '__module__', None), + 'qualname': getattr(obj, '__qualname__', getattr(obj, '__name__', None)), + 'type_module': type(obj).__module__, 'type_name': type(obj).__name__} + for name, obj in selected.items()} + return selected, names + + +def closure(runtime, package, entry, main_path=None): + # Source-bound lazy initialization is paid setup before effective sealing. + # tempfile's first gettempdir/name-sequence otherwise legitimately rebinds + # globals during the first target mkdtemp and creates false drift. + import tempfile + need(tempfile.gettempdir() == '/tmp', 'unexpected effective temp directory') + tempfile._get_candidate_names() + need(all(name in sys.builtin_module_names for name in runtime['required_builtin_modules']), + 'required actual builtin provider missing') + need(Path(sys.executable).resolve() == Path(runtime['executable']), 'interpreter mismatch') + need(sys.version == runtime['python_version'], 'interpreter version mismatch') + need(sys.flags.isolated == 1 and sys.flags.dont_write_bytecode == 1 and sys.flags.no_site == 1, 'isolated -B -S required') + need(zlib.__spec__.origin == 'built-in' and 'zlib' in sys.builtin_module_names, + 'actual builtin zlib provider required; no fictional extension') + need(gzip.zlib is zlib, 'gzip provider differs') + need(runtime['builtin_zlib_provider'] == runtime['executable'], 'builtin provider pin differs') + for filename, expected in sorted(runtime['files'].items()): + same(Path(filename), expected) + observed = {} + for name, module in sorted(tuple(sys.modules.items())): + if module is None: + continue + filename = getattr(module, '__file__', None) + if filename is None: + spec = getattr(module, '__spec__', None) + origin = getattr(spec, 'origin', None) + need(origin in ('built-in', 'frozen') and + (origin == 'frozen' or name in sys.builtin_module_names), 'unsealed no-file module: ' + name) + continue + actual = str(Path(filename).resolve()) + if name == '__main__': + expected = str(Path(main_path or __file__).resolve()) + elif name == 'o03_entry': + expected = str(entry) + elif actual.startswith(str(package) + '/'): + relative = str(Path(actual).relative_to(package)) + need(relative in runtime['package_modules'].values(), 'undeclared package module: ' + name) + need(name in runtime['package_modules'], 'unsealed package module alias: ' + name) + expected = str(package / runtime['package_modules'][name]) + else: + expected = runtime['module_paths'].get(name) + need(actual == expected, 'unexpected runtime module origin: ' + name + '=' + actual) + observed[name] = actual + actual_maps = mappings() + need(actual_maps <= set(runtime['mapped_files']), 'unsealed mapped files: ' + repr(sorted(actual_maps - set(runtime['mapped_files'])))) + need(runtime['linked_libz'] in actual_maps, 'actual linked libz missing') + objects, descriptors = callable_bindings() + need(descriptors == runtime['callable_bindings'], 'selected implementation binding mismatch') + return {'module_origins': observed, 'mapped_files': sorted(actual_maps), + 'builtin_zlib_provider': runtime['builtin_zlib_provider'], 'linked_libz': runtime['linked_libz'], + 'selected_callable_bindings': descriptors}, objects + + +def main(): + need(len(sys.argv) == 3, 'bootstrap requires request and exact request digest') + request = read_json(Path(sys.argv[1]), sys.argv[2]) + runtime = read_json(Path(request['runtime_manifest']), request['runtime_sha256']) + package = safe(Path(request['package_custody']['root'])) + entry = safe(package / request['entry']) + need(request['entry'] in request['package_custody']['files'], 'unsealed target entry') + check_snapshot(request['package_custody']) + report = {'schema': 'o03-effective-runtime-v1', 'status': 'STARTED', 'errors': []} + before_objects = None + effective_before = None + try: + # Freeze imports used by all execution branches, including conditional helpers. + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + for name in runtime['preload_modules']: + importlib.import_module(name) + # Import the entry without running its guarded main, then freeze actual + # effective package bindings and execute exactly its reviewed main(). + sys.path.insert(0, str(entry.parent)) + sys.path.insert(1, str(package / 'loader')) + spec = importlib.util.spec_from_file_location('o03_entry', entry) + entry_module = importlib.util.module_from_spec(spec) + sys.modules['o03_entry'] = entry_module + spec.loader.exec_module(entry_module) + report['before'], before_objects = closure(runtime, package, entry) + effective_before = capture(dict(sys.modules)) + report['effective_before'] = effective_before + sys.argv = [str(entry), *request['argv']] + entry_module.main() + report['target_returned'] = True + except SystemExit as error: + report['target_exit'] = error.code + if error.code not in (0, None): + report['errors'].append({'type': 'SystemExit', 'message': str(error.code)}) + except BaseException as error: + report['errors'].append({'type': type(error).__name__, 'message': str(error)}) + finally: + try: + report['after'], after_objects = closure(runtime, package, entry) + report['effective_after'] = capture(dict(sys.modules)) + need(effective_before is not None, 'effective before seal absent') + unchanged(effective_before, report['effective_after']) + need(before_objects is not None and all(after_objects[k] is v for k, v in before_objects.items()), + 'callable rebound during target') + check_snapshot(request['package_custody']) + except BaseException as error: + report['errors'].append({'check': 'after', 'type': type(error).__name__, 'message': str(error)}) + report['status'] = 'PASS' if not report['errors'] else 'STOP' + write_json(Path(request['runtime_report']), report) + need(report['status'] == 'PASS', 'effective runtime/target failure') + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/custody.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/custody.py new file mode 100644 index 0000000000..c7aaad3522 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/custody.py @@ -0,0 +1,131 @@ +"""Immutable copies and fresh identity authentication. No target imports.""" +import hashlib +import json +import os +from pathlib import Path +import stat + +CHUNK = 65536 + + +def need(ok, message): + if not ok: + raise RuntimeError(message) + + +def safe(path): + path = Path(path) + need(path.is_absolute() and path.resolve() == path, 'noncanonical/symlink path: ' + str(path)) + for ancestor in (path, *path.parents): + need(not ancestor.is_symlink(), 'symlink ancestor: ' + str(ancestor)) + return path + + +def fields(info, directory=False): + result = {key: getattr(info, 'st_' + key) for key in + ('dev', 'ino', 'uid', 'gid', 'nlink', 'mtime_ns', 'ctime_ns')} + result['mode'] = stat.S_IMODE(info.st_mode) + if not directory: + result['size'] = info.st_size + return result + + +def pin(path, immutable=False): + path = safe(path) + before = path.lstat() + need(stat.S_ISREG(before.st_mode) and before.st_nlink == 1, 'regular unique-link file required') + if immutable: + need(stat.S_IMODE(before.st_mode) == 0o444, 'immutable0444 required') + fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK) + with os.fdopen(fd, 'rb', buffering=0) as stream: + opened = os.fstat(stream.fileno()) + h, count = hashlib.sha256(), 0 + while True: + data = stream.read(CHUNK) + if not data: + break + h.update(data) + count += len(data) + after = os.fstat(stream.fileno()) + need(fields(before) == fields(opened) == fields(after) == fields(path.lstat()), 'identity drift') + need(count == after.st_size, 'size drift') + return dict(fields(after), sha256=h.hexdigest()) + + +def same(path, expected, immutable=False): + actual = pin(path, immutable) + need(all(actual.get(k) == v for k, v in expected.items()), 'pin mismatch: ' + str(path)) + return actual + + +def read_json(path, expected_sha=None): + path = safe(path) + info = pin(path) + need(info['size'] <= 4 * 1024 * 1024, 'metadata cap') + if expected_sha is not None: + need(info['sha256'] == expected_sha, 'metadata anchor mismatch') + raw = path.read_bytes() + need(hashlib.sha256(raw).hexdigest() == info['sha256'], 'metadata read drift') + return json.loads(raw) + + +def write_json(path, value): + raw = (json.dumps(value, sort_keys=True, indent=2, allow_nan=False) + '\n').encode() + need(len(raw) <= 4 * 1024 * 1024, 'metadata cap') + with Path(path).open('xb') as stream: + stream.write(raw) + stream.flush() + os.fsync(stream.fileno()) + + +def stage(root, sources): + """sources maps safe relative destination to {path,sha256,size,mode optional}.""" + root = safe(root) + root.mkdir(mode=0o700) + for name, spec in sorted(sources.items()): + relative = Path(name) + need(not relative.is_absolute() and '..' not in relative.parts, 'unsafe relative copy') + source = safe(Path(spec['path'])) + before = same(source, {k: v for k, v in spec.items() if k != 'path'}) + destination = root / relative + destination.parent.mkdir(parents=True, exist_ok=True, mode=0o700) + with source.open('rb') as src, destination.open('xb') as dst: + while True: + data = src.read(CHUNK) + if not data: + break + dst.write(data) + dst.flush() + os.fsync(dst.fileno()) + destination.chmod(0o444) + copied = pin(destination, True) + need(copied['sha256'] == before['sha256'] and copied['size'] == before['size'], 'copy mismatch') + need((copied['dev'], copied['ino']) != (before['dev'], before['ino']), 'copy aliases source') + same(source, before) + directories = sorted((p for p in root.rglob('*') if p.is_dir()), key=lambda p: len(p.parts), reverse=True) + for directory in directories: + directory.chmod(0o555) + root.chmod(0o555) + return snapshot(root) + + +def snapshot(root): + root = safe(root) + need(root.is_dir() and stat.S_IMODE(root.stat().st_mode) == 0o555, 'root0555 required') + files, directories = {}, {} + for path in sorted(root.rglob('*')): + safe(path) + if path.is_dir(): + need(stat.S_IMODE(path.stat().st_mode) == 0o555, 'directory0555 required') + directories[str(path.relative_to(root))] = fields(path.stat(), True) + else: + files[str(path.relative_to(root))] = pin(path, True) + identities = [(v['dev'], v['ino']) for v in files.values()] + need(len(identities) == len(set(identities)), 'aliased staged files') + return {'schema': 'h25-input-custody-v1', 'root': str(root), + 'root_identity': fields(root.stat(), True), 'directories': directories, 'files': files} + + +def check_snapshot(custody): + need(snapshot(Path(custody['root'])) == custody, 'fresh custody mismatch') + return {'files': len(custody['files']), 'fresh_full_read': True} diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/effective.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/effective.py new file mode 100644 index 0000000000..22b85b723d --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/effective.py @@ -0,0 +1,86 @@ +"""Source-derived callable/class/default/global binding fingerprints. + +Only ordinary interpreter metadata is inspected; descriptors and target functions +are never invoked. Mutable cache contents are not frozen. Binding identities, +Python code/defaults/closures, builtin authority and all class methods are. +""" +import builtins +import hashlib +import json +import marshal +from pathlib import Path +import types +from custody import need + + +def value(obj, depth=0): + if type(obj) in (str, int, bool, float, bytes, type(None)): + return [type(obj).__name__, repr(obj)] + if depth < 8 and type(obj) in (tuple, list): + return [type(obj).__name__, [value(x, depth + 1) for x in obj]] + if depth < 8 and type(obj) is dict: + return ['dict', sorted((repr(k), value(v, depth + 1)) for k, v in obj.items())] + return ['identity', type(obj).__module__, type(obj).__qualname__, id(obj)] + + +def fingerprint(module): + seen, rows = set(), [] + def visit(label, obj, depth=0): + if id(obj) in seen or depth > 16: + return + seen.add(id(obj)) + if type(obj) is types.FunctionType: + code = obj.__code__ + names = set(code.co_names) + global_bindings = [] + for name in sorted(names): + if name in obj.__globals__: + bound = obj.__globals__[name] + global_bindings.append((name, id(bound), type(bound).__module__, type(bound).__qualname__)) + if isinstance(bound, (types.FunctionType, type)): + visit(label + '.global.' + name, bound, depth + 1) + elif hasattr(builtins, name): + bound = vars(builtins)[name] + global_bindings.append(('builtins.' + name, id(bound), type(bound).__name__)) + rows.append((label, 'function', id(obj), hashlib.sha256(marshal.dumps(code)).hexdigest(), + value(obj.__defaults__), value(obj.__kwdefaults__), + [value(cell.cell_contents) for cell in (obj.__closure__ or ())], global_bindings, + id(obj.__builtins__))) + wrapped = vars(obj).get('__wrapped__') + if wrapped is not None: + visit(label + '.__wrapped__', wrapped, depth + 1) + elif isinstance(obj, type): + rows.append((label, 'class', id(obj), [(b.__module__, b.__qualname__, id(b)) for b in obj.__bases__])) + for name, bound in sorted(vars(obj).items()): + if isinstance(bound, (staticmethod, classmethod)): + bound = bound.__func__ + if isinstance(bound, property): + for suffix in ('fget', 'fset', 'fdel'): + function = getattr(bound, suffix) + if function is not None: + visit(label + '.' + name + '.' + suffix, function, depth + 1) + elif isinstance(bound, (types.FunctionType, type, types.BuiltinFunctionType, + types.MethodDescriptorType, types.WrapperDescriptorType)): + visit(label + '.' + name, bound, depth + 1) + elif isinstance(obj, (types.BuiltinFunctionType, types.MethodDescriptorType, types.WrapperDescriptorType)): + rows.append((label, 'native', id(obj), getattr(obj, '__module__', None), getattr(obj, '__qualname__', None))) + for name, obj in sorted(vars(module).items()): + if isinstance(obj, (types.FunctionType, type, types.BuiltinFunctionType)): + visit(name, obj) + elif name.isupper() and type(obj) in (tuple, str, int, bool, dict, list): + rows.append((name, 'constant', value(obj))) + raw = json.dumps(rows, sort_keys=True, separators=(',', ':')).encode() + return {'sha256': hashlib.sha256(raw).hexdigest(), 'binding_rows': len(rows)} + + +def capture(modules): + result = {} + for name, module in sorted(modules.items()): + if module is not None and getattr(module, '__file__', None): + result[name] = fingerprint(module) + return result + + +def unchanged(before, after): + for name, expected in before.items(): + need(after.get(name) == expected, 'effective callable/class/default/global binding drift: ' + name) diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/loader_controls.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/loader_controls.py new file mode 100644 index 0000000000..0e09204abc --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/loader_controls.py @@ -0,0 +1,23 @@ +"""Receipt adapter for the independently frozen39 loader controls.""" +import argparse +from pathlib import Path +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +sys.path.insert(1, str(Path(__file__).resolve().parent.parent / 'loader')) +from custody import need, write_json +import frozen_input_controls + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--output-root', required=True) + parser.add_argument('--receipt', required=True) + args = parser.parse_args() + Path(args.output_root).mkdir(mode=0o700) + result = frozen_input_controls.run_controls() + need(result['status'] == 'LOADER_CONTROLS_PASS' and result['count'] == 39, 'loader controls mismatch') + write_json(Path(args.receipt), result) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer.py new file mode 100644 index 0000000000..fe3e9cfc05 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer.py @@ -0,0 +1,266 @@ +"""Inclusive observer/serialized admission. Final one-write tail remains OPEN_NOT_ZERO. + +The first Python instruction starts the operation timer before other imports, +source authentication, staging, controls or target imports. Interpreter startup +before this instruction is additionally visible to an enclosing canonical guard; +never report it as zero or as a measured portion of this timer. +""" +import time +START = time.monotonic() +import resource +SELF_START = resource.getrusage(resource.RUSAGE_SELF) +CHILD_START = resource.getrusage(resource.RUSAGE_CHILDREN) +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import signal +import subprocess +import sys +import threading +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, pin, read_json, safe, same, write_json + +RSS_CAP = 1073741824 +TIME_CAP = 180.0 +INTERVAL = 0.01 +LOG_CAP = 4 * 1024 * 1024 + + +def process_table(): + result = {} + for path in Path('/proc').iterdir(): + if not path.name.isdecimal(): + continue + try: + raw = (path / 'stat').read_text() + row = raw[raw.rfind(')') + 2:].split() + result[int(path.name)] = {'state': row[0], 'ppid': int(row[1]), 'pgrp': int(row[2]), + 'start_ticks': int(row[19]), 'rss_bytes': max(0, int(row[21])) * os.sysconf('SC_PAGE_SIZE')} + except (OSError, ValueError, IndexError): + continue + return result + + +def sample_tree(root, known): + table = process_table() + members = {root} if root in table else set() + changed = True + while changed: + added = {pid for pid, info in table.items() if info['ppid'] in members} - members + changed = bool(added) + members |= added + # Keep previously seen identities even after reparenting; PID reuse is rejected. + for pid, start in tuple(known.items()): + if pid in table and table[pid]['start_ticks'] == start: + members.add(pid) + for pid in members: + known[pid] = table[pid]['start_ticks'] + return sum(table[pid]['rss_bytes'] for pid in members), table, members + + +def terminate(process, known): + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + table = process_table() + for pid, start in known.items(): + if pid != os.getpid() and pid in table and table[pid]['start_ticks'] == start: + try: + os.kill(pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + + +def observe(command, cwd, folder, deadline, rss_cap=RSS_CAP, interval=INTERVAL): + """Observe current parent plus all discoverable descendants, including cleanup.""" + folder = Path(folder) + folder.mkdir(mode=0o700) + known, peak, samples, termination = {}, 0, 0, None + start = time.monotonic() + out_path, err_path = folder / 'stdout.txt', folder / 'stderr.txt' + child = None + old_handlers = {} + signals = [] + def interrupted(signum, frame): + signals.append(signum) + for signum in (signal.SIGINT, signal.SIGTERM): + old_handlers[signum] = signal.signal(signum, interrupted) + try: + with out_path.open('xb') as out, err_path.open('xb') as err: + child = subprocess.Popen(command, cwd=cwd, stdin=subprocess.DEVNULL, stdout=out, + stderr=err, start_new_session=True, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C.UTF-8', 'TZ': 'UTC', + 'PYTHONDONTWRITEBYTECODE': '1'}) + while True: + rss, table, members = sample_tree(os.getpid(), known) + peak, samples = max(peak, rss), samples + 1 + if rss > rss_cap: + termination = 'sampled_tree_rss_cap' + elif time.monotonic() > deadline: + termination = 'wall_or_aggregate_cap' + elif signals: + termination = 'signal_' + str(signals[0]) + elif max(out_path.stat().st_size, err_path.stat().st_size) > LOG_CAP: + termination = 'retained_log_cap' + code = child.poll() + if termination is not None: + terminate(child, known) + code = child.returncode + break + if code is not None: + break + time.sleep(interval) + # All known living descendants make this command fail, even if main returned0. + rss, table, members = sample_tree(os.getpid(), known) + peak, samples = max(peak, rss), samples + 1 + survivors = sorted(pid for pid in members if pid != os.getpid() and pid in table and table[pid]['state'] != 'Z') + if survivors: + termination = termination or 'surviving_descendants' + terminate(child, known) + logs = {'stdout': pin(out_path), 'stderr': pin(err_path)} + need(all(v['size'] <= LOG_CAP for v in logs.values()), 'log cap on closing readback') + return {'command': command, 'exit': code, 'termination': termination, + 'wall_seconds': time.monotonic() - start, 'sampled_simultaneous_tree_rss_bytes': peak, + 'samples': samples, 'interval_seconds': interval, + 'tracked_identities': {str(k): v for k, v in sorted(known.items())}, + 'survivors_before_cleanup': survivors, 'logs': logs, + 'limits': {'rss_bytes': rss_cap, 'deadline_monotonic': deadline}} + finally: + if child is not None and child.poll() is None: + terminate(child, known) + for signum, handler in old_handlers.items(): + signal.signal(signum, handler) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--admission', required=True) + parser.add_argument('--admission-sha256', required=True) + args = parser.parse_args() + # Observe parent authentication and closing checks too; target work is also + # continuously sampled by this thread, independently of the foreground guard. + stop_sampling, inclusive_known = threading.Event(), {} + inclusive = {'peak': 0, 'samples': 0, 'errors': []} + def sampler(): + while not stop_sampling.is_set(): + try: + rss, _, _ = sample_tree(os.getpid(), inclusive_known) + inclusive['peak'] = max(inclusive['peak'], rss) + inclusive['samples'] += 1 + except BaseException as error: + inclusive['errors'].append(type(error).__name__ + ': ' + str(error)) + stop_sampling.wait(INTERVAL) + sampling_thread = threading.Thread(target=sampler, name='inclusive-rss-observer', daemon=True) + sampling_thread.start() + admission = read_json(Path(args.admission), args.admission_sha256) + need(admission['schema'] == 'o03-envelope-admission-v1', 'admission schema') + need(admission['independent_source_accepted'] is True and admission['parent_execution_admitted'] is True, + 'explicit independent source and parent admission required') + need(admission['maximum_command_seconds'] == TIME_CAP and admission['sampled_group_cap_bytes'] == RSS_CAP, + 'caps differ') + ledger = admission['canonical_ledger'] + need(ledger['cap_seconds'] == 2400 and 0 <= ledger['spent_seconds'] < 2400, 'canonical budget invalid') + lock_path = safe(Path(ledger['lock_path'])) + with lock_path.open('a+b') as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + for filename, expected in ledger['fresh_files'].items(): + same(Path(filename), expected) + # Consume before source checks/staging so failures cannot reroll this fixed operation. + consumed = Path(admission['consumed_marker']) + with consumed.open('xb') as marker: + marker.write((args.admission_sha256 + '\n').encode('ascii')) + marker.flush() + os.fsync(marker.fileno()) + folder = safe(Path(admission['operation_root'])) + folder.mkdir(mode=0o700) + record = {'schema': 'o03-inclusive-observer-v1', 'status': 'STARTED', + 'admission_sha256': args.admission_sha256, 'errors': [], + 'outside_tail': {'final_observer_record_writes': 1, 'parent_readbacks': 1, + 'cost': 'OPEN_NOT_ZERO', 'publication': 'OPEN_NOT_ZERO'}, + 'measurement': {'sampled_rss': 'simultaneous observer parent plus discoverable descendants', + 'limitations': '10ms sampling can miss short peaks/processes; PID start ticks prevent reuse conflation; an unseen reparented/escaped process can be missed; proc RSS includes shared pages per process; no exact true peak claim', + 'cpu': 'entire fresh observer lifetime SELF plus reaped-children rusage; child usage includes descendants reaped by their parents; no summing sampled CPU', + 'individual_maxrss': 'kernel SELF and CHILDREN maxima are separate individual process high water marks; never summed as concurrent peak', + 'interpreter_startup': 'before first Python instruction is measured only by enclosing canonical guard; OPEN_NOT_ZERO otherwise', + 'cgroup_peak': 'NOT_COLLECTED; no cgroup isolation/peak claim'}} + try: + need(admission['operation'] in admission['fixed_order'], 'undeclared operation') + index = admission['fixed_order'].index(admission['operation']) + need(len(set(admission['fixed_order'])) == len(admission['fixed_order']), 'duplicate operation labels') + if index: + previous = read_json(Path(admission['previous_observer_receipt']), admission['previous_observer_sha256']) + need(previous['status'] == 'PASS' and previous['operation'] == admission['fixed_order'][index - 1], 'fixed predecessor missing/failed') + for filename, expected in admission['envelope_source_files'].items(): + same(Path(filename), expected) + from bootstrap import closure + from effective import capture, unchanged + runtime = read_json(Path(admission['runtime_manifest']), admission['runtime_sha256']) + import importlib + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + for name in runtime['preload_modules']: + importlib.import_module(name) + record['observer_runtime_before'], observer_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + record['effective_before'] = effective_before + worker = Path(admission['worker']) + need(str(worker) in admission['envelope_source_files'], 'worker source unsealed') + command = [admission['interpreter'], '-B', '-I', '-S', str(worker), '--admission', + str(Path(args.admission)), '--admission-sha256', args.admission_sha256] + remaining = ledger['cap_seconds'] - ledger['spent_seconds'] + record['execution'] = observe(command, str(folder), folder / 'guard', + START + min(TIME_CAP, remaining)) + need(record['execution']['exit'] == 0 and record['execution']['termination'] is None, + 'worker/guard failure') + need(record['execution']['logs']['stderr']['size'] == 0, 'worker stderr') + worker_receipt = read_json(folder / 'worker-receipt.json') + need(worker_receipt['status'] == 'PASS', 'worker receipt failure') + record['worker_receipt'] = pin(folder / 'worker-receipt.json') + for filename, expected in admission['envelope_source_files'].items(): + same(Path(filename), expected) + for filename, expected in ledger['fresh_files'].items(): + same(Path(filename), expected) + except BaseException as error: + record['errors'].append({'type': type(error).__name__, 'message': str(error)}) + try: + record['observer_runtime_after'], after_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(after_objects[k] is v for k, v in observer_objects.items()), 'observer callable drift') + record['effective_after'] = capture(dict(sys.modules)) + unchanged(effective_before, record['effective_after']) + except BaseException as error: + record['errors'].append({'check': 'observer-runtime-after', 'type': type(error).__name__, 'message': str(error)}) + stop_sampling.set() + sampling_thread.join() + record['inclusive_sampled_simultaneous_tree_rss_bytes'] = inclusive['peak'] + record['inclusive_samples'] = inclusive['samples'] + record['inclusive_sampler_errors'] = inclusive['errors'] + if inclusive['peak'] > RSS_CAP or inclusive['errors']: + record['errors'].append({'type': 'SamplerFailure', 'message': 'inclusive cap/sampler failure'}) + record['operation'] = admission['operation'] + self_end, child_end = resource.getrusage(resource.RUSAGE_SELF), resource.getrusage(resource.RUSAGE_CHILDREN) + record['cpu_seconds'] = {'parent_user': self_end.ru_utime, + 'parent_system': self_end.ru_stime, + 'reaped_children_user': child_end.ru_utime, + 'reaped_children_system': child_end.ru_stime} + record['kernel_individual_maxrss_kib'] = {'observer_self_lifetime': self_end.ru_maxrss, + 'reaped_children_individual_maximum': child_end.ru_maxrss} + record['inclusive_wall_seconds'] = time.monotonic() - START + record['policy_charge_seconds'] = record['inclusive_wall_seconds'] + if record['inclusive_wall_seconds'] > min(TIME_CAP, 2400 - ledger['spent_seconds']): + record['errors'].append({'type': 'CapFailure', 'message': 'closing checks exceeded cap'}) + record['status'] = 'PASS' if not record['errors'] else 'STOP' + # The finite final write and exactly one parent readback are outside above endpoint. + write_json(folder / 'observer-receipt.json', record) + if record['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer_controls.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer_controls.py new file mode 100644 index 0000000000..655feb5eb5 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer_controls.py @@ -0,0 +1,68 @@ +"""Six fixed concrete observer controls. Run only under admitted outer guard.""" +import argparse +import os +from pathlib import Path +import sys +import time +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, write_json +from observer import observe, process_table + +CASES = ('bounded-child-allocation', 'concurrent-parent-child-allocation', 'short-lived-child', + 'timeout-kill-reap', 'tracked-orphan-cleanup', 'sampled-cap-kill-reap') + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--output-root', required=True) + parser.add_argument('--receipt', required=True) + parser.add_argument('--runtime-manifest', required=True) + parser.add_argument('--runtime-sha256', required=True) + args = parser.parse_args() + root = Path(args.output_root) + root.mkdir(mode=0o700) + fixture = str(Path(__file__).resolve().with_name('observer_fixture.py')) + rows = [] + modes = ('allocation', 'concurrent', 'short', 'timeout', 'orphan', 'allocation-cap') + for index, (name, mode) in enumerate(zip(CASES, modes)): + parent = None + before_rss = process_table()[os.getpid()]['rss_bytes'] + if mode == 'concurrent': + parent = bytearray(16 * 1024 * 1024) + for offset in range(0, len(parent), 4096): + parent[offset] = 1 + cap = before_rss + 24 * 1024 * 1024 if mode == 'allocation-cap' else 1073741824 + deadline = time.monotonic() + (0.08 if mode == 'timeout' else 5.0) + row = observe([sys.executable, '-B', '-I', '-S', fixture, mode, args.runtime_manifest, args.runtime_sha256], str(root), root / ('case-%02d' % index), + deadline, rss_cap=cap) + need(row['logs']['stderr']['size'] == 0, 'fixture stderr') + if mode in ('allocation', 'concurrent', 'short'): + need(row['exit'] == 0 and row['termination'] is None, name + ' failed') + elif mode == 'timeout': + need(row['termination'] == 'wall_or_aggregate_cap' and row['exit'] != 0, 'timeout not detected') + elif mode == 'orphan': + need(row['termination'] == 'surviving_descendants' and row['survivors_before_cleanup'], 'orphan not detected') + else: + need(row['termination'] == 'sampled_tree_rss_cap' and row['exit'] != 0, 'memory cap not detected') + if mode == 'allocation': + need(row['sampled_simultaneous_tree_rss_bytes'] >= before_rss + 16 * 1024 * 1024, 'child allocation missed') + if mode == 'concurrent': + need(row['sampled_simultaneous_tree_rss_bytes'] >= before_rss + 48 * 1024 * 1024, 'concurrent allocation missing') + need(len(row['tracked_identities']) >= 3, 'grandchild membership missing') + now = process_table() + # Linux orphan zombies can remain awaiting init; they have zero RSS and do + # no work. A surviving same-identity non-zombie is a cleanup failure. + survivors = [int(pid) for pid, tick in row['tracked_identities'].items() + if int(pid) != os.getpid() and int(pid) in now and + now[int(pid)]['start_ticks'] == tick and now[int(pid)]['rss_bytes'] > 0] + need(not survivors, 'live fixture survived cleanup') + rows.append({'case': name, 'status': 'PASS', 'measurement': row, + 'short_peak_guaranteed_observed': False}) + del parent + write_json(Path(args.receipt), {'schema': 'o03-observer-controls-v1', 'status': 'PASS', + 'case_count': 6, 'ordered_cases': list(CASES), 'cases': rows, + 'sampling_limits_exposed': True, 'synthetic_controls_are_full_serializer_evidence': False}) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer_fixture.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer_fixture.py new file mode 100644 index 0000000000..c2400182dd --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/observer_fixture.py @@ -0,0 +1,54 @@ +"""Fixed small observer-control child; never used as a serializer substitute.""" +import os +from pathlib import Path +import subprocess +import sys +import time + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from bootstrap import closure +from custody import need, read_json +from effective import capture, unchanged + + +def main(): + mode = sys.argv[1] + runtime_path, runtime_sha = sys.argv[2:4] + runtime = read_json(Path(runtime_path), runtime_sha) + package = Path(__file__).resolve().parent.parent + before, objects = closure(runtime, package, Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + if mode == 'allocation': + data = bytearray(16 * 1024 * 1024) + for i in range(0, len(data), 4096): + data[i] = 1 + time.sleep(0.20) + elif mode == 'concurrent': + data = bytearray(16 * 1024 * 1024) + for i in range(0, len(data), 4096): + data[i] = 1 + child = subprocess.Popen([sys.executable, '-B', '-I', '-S', str(Path(__file__).resolve()), 'allocation', runtime_path, runtime_sha]) + child.wait() + if child.returncode: + raise SystemExit(child.returncode) + elif mode == 'short': + data = bytearray(1024) + elif mode == 'timeout': + time.sleep(2.0) + elif mode == 'orphan': + subprocess.Popen([sys.executable, '-B', '-I', '-S', str(Path(__file__).resolve()), 'timeout', runtime_path, runtime_sha]) + time.sleep(0.15) + elif mode == 'allocation-cap': + data = bytearray(32 * 1024 * 1024) + for i in range(0, len(data), 4096): + data[i] = 1 + time.sleep(0.20) + else: + raise RuntimeError('undeclared fixture mode') + after, actual = closure(runtime, package, Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(actual[k] is v for k, v in objects.items()), 'fixture callable drift') + unchanged(effective_before, capture(dict(sys.modules))) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/sequence_worker.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/sequence_worker.py new file mode 100644 index 0000000000..bb92d5bdba --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/sequence_worker.py @@ -0,0 +1,87 @@ +"""Fixed eight-operation serial coordinator inside one inclusive180s command. + +One outer observer receipt and one parent readback close this finite operation. +No intermediate parent process/action, retries, rerolls or fresh admission from +candidate observations. Every child is reaped before the next child starts. +""" +import argparse +import hashlib +from pathlib import Path +import subprocess +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import need, pin, read_json, write_json + +ORDER = ('observer-controls', 'loader-controls-normal', 'consumer-controls-normal', + 'loader-controls-O', 'consumer-controls-O', 'baseline-first', 'candidate-first', 'independent-validation') + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--admission', required=True) + parser.add_argument('--admission-sha256', required=True) + args = parser.parse_args() + admission = read_json(Path(args.admission), args.admission_sha256) + need(admission['operation'] == 'complete-fixed-o03', 'fixed operation required') + need(tuple(job['id'] for job in admission['sequence']) == ORDER, 'fixed serial order differs') + root = Path(admission['operation_root']) + steps = root / 'steps' + steps.mkdir(mode=0o700) + state = {'schema': 'o03-fixed-sequence-v1', 'status': 'STARTED', 'ordered_operations': list(ORDER), 'steps': [], 'errors': []} + try: + from custody import same + from bootstrap import closure + from effective import capture, unchanged + import importlib + runtime = read_json(Path(admission['runtime_manifest']), admission['runtime_sha256']) + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + for name in runtime['preload_modules']: + importlib.import_module(name) + state['runtime_before'], objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + for job in admission['sequence']: + step_root = steps / job['id'] + step_root.mkdir(mode=0o700) + child = dict(admission, operation=job['id'], operation_root=str(step_root), job=job) + child.pop('sequence') + child['dependency_receipts'] = {} + child['dependency_output_roots'] = {} + if job['id'] == 'independent-validation': + for arm, label in (('baseline', 'baseline-first'), ('candidate', 'candidate-first')): + prior_root = steps / label + child['dependency_receipts'][arm + '_receipt'] = { + 'path': str(prior_root / 'target-receipt.json'), 'pin': pin(prior_root / 'target-receipt.json')} + child['dependency_output_roots'][arm + '_root'] = str(prior_root / 'outputs') + path = root / (job['id'] + '-request.json') + write_json(path, child) + sha = pin(path)['sha256'] + command = [admission['interpreter'], '-B', '-I', '-S', str(Path(__file__).resolve().with_name('worker.py')), + '--admission', str(path), '--admission-sha256', sha] + completed = subprocess.run(command, cwd=root, stdin=subprocess.DEVNULL, check=False) + row = {'id': job['id'], 'exit': completed.returncode, 'request': pin(path)} + state['steps'].append(row) + need(completed.returncode == 0, 'fixed operation failed: ' + job['id']) + receipt = read_json(step_root / 'worker-receipt.json') + need(receipt['status'] == 'PASS', 'worker receipt failed') + row['worker_receipt'] = pin(step_root / 'worker-receipt.json') + # Full independent validator already performed byte/receipt/cleanup checks; + # all step receipts are reread here inside observation, never outside tail. + for row in state['steps']: + expected = row['worker_receipt'] + need(pin(steps / row['id'] / 'worker-receipt.json') == expected, 'step receipt drift') + state['runtime_after'], actual = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(actual[k] is v for k, v in objects.items()), 'sequence callable drift') + unchanged(effective_before, capture(dict(sys.modules))) + except BaseException as error: + state['errors'].append({'type': type(error).__name__, 'message': str(error)}) + state['status'] = 'PASS' if not state['errors'] else 'STOP' + write_json(root / 'worker-receipt.json', state) + if state['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/worker.py b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/worker.py new file mode 100644 index 0000000000..505a190e91 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/rejected-envelope-v1/worker.py @@ -0,0 +1,119 @@ +"""Single fixed-operation coordinator inside inclusive observer; no target imports.""" +import argparse +import hashlib +import os +from pathlib import Path +import subprocess +import sys +sys.path.insert(0, str(Path(__file__).resolve().parent)) +from custody import check_snapshot, need, pin, read_json, safe, same, stage, write_json + + +def subst(value, bindings): + for key, replacement in bindings.items(): + value = value.replace('{' + key + '}', replacement) + need('{' not in value and '}' not in value, 'unresolved command binding') + return value + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--admission', required=True) + parser.add_argument('--admission-sha256', required=True) + args = parser.parse_args() + admission = read_json(Path(args.admission), args.admission_sha256) + operation = admission['operation'] + root = safe(Path(admission['operation_root'])) + job = admission['job'] + need(job['id'] == operation, 'operation/job mismatch') + state = {'schema': 'o03-worker-receipt-v1', 'operation': operation, 'status': 'STARTED', 'errors': []} + package_custody, input_custody = None, None + try: + # Fresh separately owned copies are made under the already live outer observation. + package_custody = stage(root / 'package', admission['package_sources']) + state['package_before'] = package_custody + runtime = read_json(Path(admission['runtime_manifest']), admission['runtime_sha256']) + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + from bootstrap import closure + from effective import capture, unchanged + import importlib + for name in runtime['preload_modules']: + importlib.import_module(name) + state['worker_runtime_before'], worker_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + effective_before = capture(dict(sys.modules)) + state['effective_before'] = effective_before + bindings = {'package': str(root / 'package'), 'operation_root': str(root), + 'output_root': str(root / 'outputs'), 'receipt': str(root / 'target-receipt.json'), + 'runtime_manifest': admission['runtime_manifest'], 'runtime_sha256': admission['runtime_sha256']} + if job['needs_authentic_inputs']: + input_custody = stage(root / 'inputs', admission['input_sources']) + # Loader schema exact: no wrapper/metadata extra file enters the input root. + write_json(root / 'input-custody.json', input_custody) + state['input_before'] = input_custody + bindings.update(input_root=str(root / 'inputs'), custody_json=str(root / 'input-custody.json')) + for key, spec in admission.get('dependency_receipts', {}).items(): + path = safe(Path(spec['path'])) + same(path, spec['pin']) + bindings[key] = str(path) + for key, directory in admission.get('dependency_output_roots', {}).items(): + bindings[key] = str(safe(Path(directory))) + argv = [subst(value, bindings) for value in job['argv']] + request = {'package_custody': package_custody, 'entry': job['entry'], 'argv': argv, + 'runtime_manifest': admission['runtime_manifest'], 'runtime_sha256': admission['runtime_sha256'], + 'runtime_report': str(root / 'effective-runtime.json')} + write_json(root / 'bootstrap-request.json', request) + request_sha = pin(root / 'bootstrap-request.json')['sha256'] + bootstrap = root / 'package/envelope/bootstrap.py' + need('envelope/bootstrap.py' in package_custody['files'], 'bootstrap absent') + command = [admission['interpreter'], '-B', '-I', '-S'] + if job['optimization'] == 1: + command.append('-O') + else: + need(job['optimization'] == 0, 'invalid optimization') + command += [str(bootstrap), str(root / 'bootstrap-request.json'), request_sha] + state['command'] = command + # The outer observer owns the only real180s/1GiB/aggregate guard and logs. + completed = subprocess.run(command, cwd=root, stdin=subprocess.DEVNULL, check=False) + state['target_exit'] = completed.returncode + need(completed.returncode == 0, 'bootstrap/target failed') + effective = read_json(root / 'effective-runtime.json') + need(effective['status'] == 'PASS', 'runtime before/after failed') + receipt = read_json(root / 'target-receipt.json') + for key, expected in job['receipt_predicates'].items(): + need(receipt.get(key) == expected, 'target receipt predicate failed: ' + key) + state['target_receipt'] = pin(root / 'target-receipt.json') + # Receipt and runtime closure readbacks, source checks and genuine-input cleanup + # checks remain substantive measured work before worker exits. + state['runtime_report'] = pin(root / 'effective-runtime.json') + for filename, expected in runtime['files'].items(): + same(Path(filename), expected) + state['worker_runtime_after'], after_objects = closure(runtime, Path(__file__).resolve().parent.parent, + Path(__file__).resolve(), main_path=Path(__file__).resolve()) + need(all(after_objects[k] is v for k, v in worker_objects.items()), 'worker callable drift') + state['effective_after'] = capture(dict(sys.modules)) + unchanged(effective_before, state['effective_after']) + for key, spec in admission.get('dependency_receipts', {}).items(): + same(Path(spec['path']), spec['pin']) + for relative in job['must_be_absent_after']: + path = root / relative + need(not path.exists() and not path.is_symlink(), 'cleanup failed: ' + relative) + except BaseException as error: + state['errors'].append({'type': type(error).__name__, 'message': str(error)}) + finally: + for name, custody in (('package_after', package_custody), ('input_after', input_custody)): + if custody is not None: + try: + state[name] = check_snapshot(custody) + except BaseException as error: + state['errors'].append({'check': name, 'type': type(error).__name__, 'message': str(error)}) + state['retention'] = 'immutable staged inputs/sources and complete first-attempt evidence intentionally retained; candidate private staging absence checked by target validator; no silently deleted failures' + state['status'] = 'PASS' if not state['errors'] else 'STOP' + write_json(root / 'worker-receipt.json', state) + if state['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main() diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-EVIDENCE-v1.json new file mode 100644 index 0000000000..7f25a771db --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-EVIDENCE-v1.json @@ -0,0 +1,386 @@ +{ + "all51_tree_entries_exact": true, + "bytes": 17384947, + "file_count": 51, + "manifest_all50_members_exact": true, + "package_files": { + "PACKAGE-MANIFEST-v1.json": { + "bytes": 14454, + "git_blob_sha1": "6889471d578aa766d0929510cbf9aa5ae2f8157c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f170e1b7e8c0e7dde8544823be361e83e46b24a1e7f5b99cd9864b71e8017122" + }, + "README.md": { + "bytes": 5174, + "git_blob_sha1": "9d107621005d53d443c9572c31b6df78656fe225", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "84f6927b46476b5c81c709ee3364904d7c07095f6a0e5a6c5bdf135bd10e85b8" + }, + "SOURCES-EXPORT-v1.json": { + "bytes": 23776, + "git_blob_sha1": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c92006685cd62c8e957c6b0521ae3f42258004991541ff8a317e63eabbbf4a5d" + }, + "SOURCES.json": { + "bytes": 1951, + "git_blob_sha1": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c9f4012e612935ecaf449859d898f357f15d14139051f55c980a56b8af37e0c6" + }, + "TASK.json": { + "bytes": 1715, + "git_blob_sha1": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "3e167e4b5659967df2f1034e051fa54b5f3253de4512cb83db4e78e4e49b31d3" + }, + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "git_blob_sha1": "cab48c3a31b095e78253899bff95548e44a32e6f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + "consumer/CONTROL-SPEC.json": { + "bytes": 3062, + "git_blob_sha1": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "consumer/DEPENDENCIES-v1.json": { + "bytes": 3934, + "git_blob_sha1": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + "consumer/PACKAGE-PINS-v1.json": { + "bytes": 2453, + "git_blob_sha1": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc" + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "git_blob_sha1": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "git_blob_sha1": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + "consumer/README-v1.md": { + "bytes": 6609, + "git_blob_sha1": "8879b820a9c05c78857964f0674ae4c4806a7726", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + "consumer/SOURCE-READINESS-v1.json": { + "bytes": 2081, + "git_blob_sha1": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + "consumer/bounded_serialization.py": { + "bytes": 23560, + "git_blob_sha1": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "consumer/full_consumer.py": { + "bytes": 9411, + "git_blob_sha1": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + "consumer/reference.py": { + "bytes": 2141, + "git_blob_sha1": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "consumer/run_controls.py": { + "bytes": 6630, + "git_blob_sha1": "1926eb081f24a953f1521ee63555fe7910a26e05", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + "consumer/serialization_controls.py": { + "bytes": 23684, + "git_blob_sha1": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "consumer/validate_outputs.py": { + "bytes": 14577, + "git_blob_sha1": "ade0aa6b46e28531797062f73b664efc8705f445", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + }, + "inputs/baseline/evidence/canonical/complex-network.json": { + "bytes": 5662, + "git_blob_sha1": "62a6091887a3894535c1d059e1b0c527d556eb76", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "inputs/baseline/evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "git_blob_sha1": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "inputs/baseline/evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "git_blob_sha1": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "loader/API-v1.md": { + "bytes": 5012, + "git_blob_sha1": "ec051bd35aad548258708278b146a037908a7dfa", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + "loader/CONTROL-SPEC-v1.json": { + "bytes": 2002, + "git_blob_sha1": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + "loader/PACKAGE-PINS-v1.json": { + "bytes": 1152, + "git_blob_sha1": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71" + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "git_blob_sha1": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + "loader/SOURCE-PINS-v1.json": { + "bytes": 2395, + "git_blob_sha1": "b584cb6cdee15071f76918e1055a224000c5f255", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + "loader/SOURCE-READINESS-v1.json": { + "bytes": 2306, + "git_blob_sha1": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + "loader/frozen_h25_inputs.py": { + "bytes": 14650, + "git_blob_sha1": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "loader/frozen_input_controls.py": { + "bytes": 13181, + "git_blob_sha1": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + }, + "provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json": { + "bytes": 2945, + "git_blob_sha1": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5b44b61996e11eae2d495fbdfbd20e221fac99937a44491dff3166af45466c6d" + }, + "provenance/feasibility/contract/DECISION-v1.json": { + "bytes": 9046, + "git_blob_sha1": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6d9bf443793f6ca6eaef574faa7935a52d8f510abcb0ae8371d59b608ba1a9c8" + }, + "provenance/feasibility/contract/O03-MATRIX-v1.json": { + "bytes": 18742, + "git_blob_sha1": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "99720019aaec5273e9da703e83c1795741a8d0fbba1b3d0e9b571dca2f4fe60c" + }, + "provenance/feasibility/review/REVIEW-v1.json": { + "bytes": 10656, + "git_blob_sha1": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "387ce2469788a5b93e35abb5472780d8421a065fd91b7ebcb1044cf8af0a9780" + }, + "provenance/feasibility/technical/FEASIBILITY-v1.json": { + "bytes": 11462, + "git_blob_sha1": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ce706af4d4092be6f23c69aa5d2dc66929442c182f18a34366f4ba8e5cf53f27" + }, + "provenance/feasibility/technical/PROBE-SPEC-v1.json": { + "bytes": 11830, + "git_blob_sha1": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a5885aea89261a3b1aa024e6771ed299845f4b587833a9e9e97b70802eefa2d7" + }, + "provenance/feasibility/technical/SOURCE-PINS-v1.json": { + "bytes": 12719, + "git_blob_sha1": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ad7fb8b6ac220879c6bdbb59d458d86067eabc60237378f2f396df80c1e0d9ae" + }, + "provenance/implementation/PLAN-v1.md": { + "bytes": 6135, + "git_blob_sha1": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234" + }, + "provenance/implementation/control/AUTHORIZATION-v1.json": { + "bytes": 1169, + "git_blob_sha1": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2" + }, + "provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json": { + "bytes": 3351, + "git_blob_sha1": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b39edf02587bb99c1464fab8d9bd9ea531a5bc6448eda92b95d841b4baa4fa54" + }, + "provenance/original-goal/control/PLAN-before-granular-progress-v1.md": { + "bytes": 14285, + "git_blob_sha1": "97b016c958d3e309ef884213fda3328388f69e58", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e" + }, + "provenance/original-goal/control/hourly-progress/RUBRIC-v1.json": { + "bytes": 6249, + "git_blob_sha1": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1" + }, + "provenance/original-serializer/ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "git_blob_sha1": "1767b5809d01af10dd64eb528b37f22049c53734", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "provenance/original-serializer/REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "git_blob_sha1": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "provenance/original-serializer/provenance/compare_side_verifier.py": { + "bytes": 10571, + "git_blob_sha1": "d94920c274c0a47db9763dd595230d52df0bd073", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "provenance/original-serializer/provenance/native_backend.py": { + "bytes": 20334, + "git_blob_sha1": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "provenance/original-serializer/provenance/profile_side_verifier.py": { + "bytes": 8959, + "git_blob_sha1": "807855eb875673c47da0ed1b5a890a417e28a846", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "reviews/I1-EVIDENCE-v1.json": { + "bytes": 2211, + "git_blob_sha1": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2e416ae27c6e79372e4b22d7c8ac212880e99f431504f278740e1dd2b6033aeb" + }, + "reviews/I1-REVIEW-v1.json": { + "bytes": 5166, + "git_blob_sha1": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ba00118a5c665beb5dbc12f22bf85f47c90d7bc676e4a98d3b901616cbafb115" + }, + "reviews/I2-EVIDENCE-v1.json": { + "bytes": 5912, + "git_blob_sha1": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "54567df4f843827537c9ce1a5e472f592afa6ac1462832dcad558e2f6a363c1d" + }, + "reviews/I2-REVIEW-v1.json": { + "bytes": 4600, + "git_blob_sha1": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ef8b3f12d33ce85277b90c9727545db0252c3104eb6e81444f0b82448c61881e" + } + }, + "refs": { + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/EXPORT-FREEZE-v1.json": { + "bytes": 15315, + "sha256": "5db374e8e9f8b69e574b2b24c4f4f3b8135927fbc044f1a2e7d3722ed05976f6" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/TREE-ENTRIES-v1.json": { + "bytes": 10934, + "sha256": "d1dd1293ab73b997fcca153a5bc446a56753c75e307ef1898726dd2e20478ca1" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/repository/research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v1.json": { + "bytes": 14454, + "sha256": "f170e1b7e8c0e7dde8544823be361e83e46b24a1e7f5b99cd9864b71e8017122" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/repository/research/h25-authentic-serializer-20261031/SOURCES-EXPORT-v1.json": { + "bytes": 23776, + "sha256": "c92006685cd62c8e957c6b0521ae3f42258004991541ff8a317e63eabbbf4a5d" + } + }, + "schema": "o03-independent-source-export-evidence-v1", + "source_map_copies_exact": 46, + "source_only_method": true +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-FREEZE-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-FREEZE-v1.json new file mode 100644 index 0000000000..b46ec9fa18 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-FREEZE-v1.json @@ -0,0 +1,379 @@ +{ + "I1_I2_sources_byte_exact": true, + "I3_included": false, + "activity": "Exact copies, source text/metadata reads and hashing only; no target import/execution/tests/controls/decoding/benchmarks or network.", + "execution_admitted": false, + "file_count": 51, + "files": { + "PACKAGE-MANIFEST-v1.json": { + "bytes": 14454, + "git_blob_sha1": "6889471d578aa766d0929510cbf9aa5ae2f8157c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f170e1b7e8c0e7dde8544823be361e83e46b24a1e7f5b99cd9864b71e8017122" + }, + "README.md": { + "bytes": 5174, + "git_blob_sha1": "9d107621005d53d443c9572c31b6df78656fe225", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "84f6927b46476b5c81c709ee3364904d7c07095f6a0e5a6c5bdf135bd10e85b8" + }, + "SOURCES-EXPORT-v1.json": { + "bytes": 23776, + "git_blob_sha1": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c92006685cd62c8e957c6b0521ae3f42258004991541ff8a317e63eabbbf4a5d" + }, + "SOURCES.json": { + "bytes": 1951, + "git_blob_sha1": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c9f4012e612935ecaf449859d898f357f15d14139051f55c980a56b8af37e0c6" + }, + "TASK.json": { + "bytes": 1715, + "git_blob_sha1": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "3e167e4b5659967df2f1034e051fa54b5f3253de4512cb83db4e78e4e49b31d3" + }, + "consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "git_blob_sha1": "cab48c3a31b095e78253899bff95548e44a32e6f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583" + }, + "consumer/CONTROL-SPEC.json": { + "bytes": 3062, + "git_blob_sha1": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "consumer/DEPENDENCIES-v1.json": { + "bytes": 3934, + "git_blob_sha1": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69" + }, + "consumer/PACKAGE-PINS-v1.json": { + "bytes": 2453, + "git_blob_sha1": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc" + }, + "consumer/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "git_blob_sha1": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875" + }, + "consumer/PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "git_blob_sha1": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381" + }, + "consumer/README-v1.md": { + "bytes": 6609, + "git_blob_sha1": "8879b820a9c05c78857964f0674ae4c4806a7726", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7" + }, + "consumer/SOURCE-READINESS-v1.json": { + "bytes": 2081, + "git_blob_sha1": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606" + }, + "consumer/bounded_serialization.py": { + "bytes": 23560, + "git_blob_sha1": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "consumer/full_consumer.py": { + "bytes": 9411, + "git_blob_sha1": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688" + }, + "consumer/reference.py": { + "bytes": 2141, + "git_blob_sha1": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "consumer/run_controls.py": { + "bytes": 6630, + "git_blob_sha1": "1926eb081f24a953f1521ee63555fe7910a26e05", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf" + }, + "consumer/serialization_controls.py": { + "bytes": 23684, + "git_blob_sha1": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + "consumer/validate_outputs.py": { + "bytes": 14577, + "git_blob_sha1": "ade0aa6b46e28531797062f73b664efc8705f445", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e" + }, + "inputs/baseline/evidence/canonical/complex-network.json": { + "bytes": 5662, + "git_blob_sha1": "62a6091887a3894535c1d059e1b0c527d556eb76", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f" + }, + "inputs/baseline/evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "git_blob_sha1": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa" + }, + "inputs/baseline/evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "git_blob_sha1": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0" + }, + "loader/API-v1.md": { + "bytes": 5012, + "git_blob_sha1": "ec051bd35aad548258708278b146a037908a7dfa", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677" + }, + "loader/CONTROL-SPEC-v1.json": { + "bytes": 2002, + "git_blob_sha1": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c" + }, + "loader/PACKAGE-PINS-v1.json": { + "bytes": 1152, + "git_blob_sha1": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71" + }, + "loader/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "git_blob_sha1": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4" + }, + "loader/SOURCE-PINS-v1.json": { + "bytes": 2395, + "git_blob_sha1": "b584cb6cdee15071f76918e1055a224000c5f255", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e" + }, + "loader/SOURCE-READINESS-v1.json": { + "bytes": 2306, + "git_blob_sha1": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f" + }, + "loader/frozen_h25_inputs.py": { + "bytes": 14650, + "git_blob_sha1": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a" + }, + "loader/frozen_input_controls.py": { + "bytes": 13181, + "git_blob_sha1": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c" + }, + "provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json": { + "bytes": 2945, + "git_blob_sha1": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5b44b61996e11eae2d495fbdfbd20e221fac99937a44491dff3166af45466c6d" + }, + "provenance/feasibility/contract/DECISION-v1.json": { + "bytes": 9046, + "git_blob_sha1": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6d9bf443793f6ca6eaef574faa7935a52d8f510abcb0ae8371d59b608ba1a9c8" + }, + "provenance/feasibility/contract/O03-MATRIX-v1.json": { + "bytes": 18742, + "git_blob_sha1": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "99720019aaec5273e9da703e83c1795741a8d0fbba1b3d0e9b571dca2f4fe60c" + }, + "provenance/feasibility/review/REVIEW-v1.json": { + "bytes": 10656, + "git_blob_sha1": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "387ce2469788a5b93e35abb5472780d8421a065fd91b7ebcb1044cf8af0a9780" + }, + "provenance/feasibility/technical/FEASIBILITY-v1.json": { + "bytes": 11462, + "git_blob_sha1": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ce706af4d4092be6f23c69aa5d2dc66929442c182f18a34366f4ba8e5cf53f27" + }, + "provenance/feasibility/technical/PROBE-SPEC-v1.json": { + "bytes": 11830, + "git_blob_sha1": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "a5885aea89261a3b1aa024e6771ed299845f4b587833a9e9e97b70802eefa2d7" + }, + "provenance/feasibility/technical/SOURCE-PINS-v1.json": { + "bytes": 12719, + "git_blob_sha1": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ad7fb8b6ac220879c6bdbb59d458d86067eabc60237378f2f396df80c1e0d9ae" + }, + "provenance/implementation/PLAN-v1.md": { + "bytes": 6135, + "git_blob_sha1": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234" + }, + "provenance/implementation/control/AUTHORIZATION-v1.json": { + "bytes": 1169, + "git_blob_sha1": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2" + }, + "provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json": { + "bytes": 3351, + "git_blob_sha1": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "b39edf02587bb99c1464fab8d9bd9ea531a5bc6448eda92b95d841b4baa4fa54" + }, + "provenance/original-goal/control/PLAN-before-granular-progress-v1.md": { + "bytes": 14285, + "git_blob_sha1": "97b016c958d3e309ef884213fda3328388f69e58", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "62d95b37fb62c3302403a7c7d933ae1058651fec31636c8322ca1cd4dc356e0e" + }, + "provenance/original-goal/control/hourly-progress/RUBRIC-v1.json": { + "bytes": 6249, + "git_blob_sha1": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9f987e10fc6a5027985741c2bf0e7a6e39a4103e6439e2321116034e8e4a4ea1" + }, + "provenance/original-serializer/ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "git_blob_sha1": "1767b5809d01af10dd64eb528b37f22049c53734", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "provenance/original-serializer/REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "git_blob_sha1": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "provenance/original-serializer/provenance/compare_side_verifier.py": { + "bytes": 10571, + "git_blob_sha1": "d94920c274c0a47db9763dd595230d52df0bd073", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "provenance/original-serializer/provenance/native_backend.py": { + "bytes": 20334, + "git_blob_sha1": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "provenance/original-serializer/provenance/profile_side_verifier.py": { + "bytes": 8959, + "git_blob_sha1": "807855eb875673c47da0ed1b5a890a417e28a846", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "reviews/I1-EVIDENCE-v1.json": { + "bytes": 2211, + "git_blob_sha1": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "2e416ae27c6e79372e4b22d7c8ac212880e99f431504f278740e1dd2b6033aeb" + }, + "reviews/I1-REVIEW-v1.json": { + "bytes": 5166, + "git_blob_sha1": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ba00118a5c665beb5dbc12f22bf85f47c90d7bc676e4a98d3b901616cbafb115" + }, + "reviews/I2-EVIDENCE-v1.json": { + "bytes": 5912, + "git_blob_sha1": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "54567df4f843827537c9ce1a5e472f592afa6ac1462832dcad558e2f6a363c1d" + }, + "reviews/I2-REVIEW-v1.json": { + "bytes": 4600, + "git_blob_sha1": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "git_mode": "100644", + "mode_octal": "0o444", + "sha256": "ef8b3f12d33ce85277b90c9727545db0252c3104eb6e81444f0b82448c61881e" + } + }, + "generated_files": [ + "README.md", + "TASK.json", + "SOURCES.json", + "SOURCES-EXPORT-v1.json", + "PACKAGE-MANIFEST-v1.json" + ], + "package_manifest_sha256": "f170e1b7e8c0e7dde8544823be361e83e46b24a1e7f5b99cd9864b71e8017122", + "package_root": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/repository/research/h25-authentic-serializer-20261031", + "schema": "o03-exact-source-export-freeze-v1", + "status": "FROZEN_AWAIT_INDEPENDENT_EXPORT_REVIEW", + "total_bytes": 17384947, + "tree_entries_sha256": "d1dd1293ab73b997fcca153a5bc446a56753c75e307ef1898726dd2e20478ca1" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-REVIEW-v1.json new file mode 100644 index 0000000000..c5a04dc220 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/EXPORT-REVIEW-v1.json @@ -0,0 +1,44 @@ +{ + "activity_boundary": { + "decompressions": 0, + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_calls": 0, + "target_imports": 0, + "tests_controls_benchmarks": 0 + }, + "checks": { + "I1_I2": "Exact accepted source package manifests/reviews/evidence retained; no accepted source edits.", + "authentic_transports": "All3 exact17,022,954 transport bytes included; SHA256 and Git blob identities verified raw only. No JSON payload parse or decompression. Parent remote metadata is explicitly attributed to parent record, not reviewer verification.", + "claims": "README/TASK/SOURCES explicitly unexecuted I1/I2 source proposal; I3/I4 pending, no admitted clone-and-run route, no O03/resource/gain/caller/whole-goal credit, no automatic hosted replay. Q/P and outside OPEN_NOT_ZERO retained.", + "copy_integrity": "All46 copied sources/proofs/inputs byte-exact against named live source map. All51 SHA256, Git blob SHA1, bytes/modes verified; manifest all50 nonself members and exact51 publication tree entries verified.", + "custody": "Git100644 portability limitation explicit; actual0444/0555/owner/inode stages must be newly established, no saved custody PASS.", + "portable_source_contract": "Required8 executable modules and3 specs included; consumer/loader sibling import resolution preserved; no hidden workspace executable import. Historical original paths explicitly provenance-only.", + "reference_ancestry": "Literal frozen reference/candidate/control copies unchanged; reference extraction and original compare/profile/native provenance sources retained as read-only ancestry. Native/scientific provenance is not imported by delivered consumer." + }, + "created_utc": "2026-10-31T08:16:45.542798+00:00", + "decision": "ACCEPT", + "dynamic_evidence": false, + "evidence": "EXPORT-EVIDENCE-v1.json", + "execution_admitted": false, + "export_freeze_sha256": "5db374e8e9f8b69e574b2b24c4f4f3b8135927fbc044f1a2e7d3722ed05976f6", + "limitations": [ + "Source export review does not grant I3/I4 or target execution, logical/schema payload admission, test/control outcomes,180s/1GiB fit, measurement or O03 qualification.", + "No reviewer network/PR or hosted check performed; current upstream/fork object claim comes only from included parent-owned metadata record.", + "Remote publication must use exact reviewed tree plus separately verified base/head/check/readback; changed tree or updated evidence commit requires precise new review." + ], + "original_goal_credit": 0, + "package_root": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/repository/research/h25-authentic-serializer-20261031", + "passive_attempts": [ + { + "operation": "Read guessed TASK.md/SOURCES.md names", + "result": "No such file; actual TASK.json/SOURCES.json then read successfully; no target effect" + } + ], + "publication_scope_accepted": true, + "schema": "o03-independent-source-export-review-v1", + "scope": "Exact51-file17384947-byte portable source proposal export for already accepted I1/I2 source lanes, originals/controls/authentic transports and carried provenance only. No envelope/execution admission or qualification.", + "tree_entries_sha256": "d1dd1293ab73b997fcca153a5bc446a56753c75e307ef1898726dd2e20478ca1" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-PR-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-PR-EVIDENCE-v1.json new file mode 100644 index 0000000000..8a6105be2f --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-PR-EVIDENCE-v1.json @@ -0,0 +1,124 @@ +{ + "check_runs": [ + { + "check_suite": 111639678067, + "conclusion": "skipped", + "details_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/41184756965/job/124490234925", + "head_sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/41184756965/job/124490234925", + "id": 124490234925, + "name": "replay", + "status": "completed" + }, + { + "check_suite": 111639678067, + "conclusion": "success", + "details_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/41184756965/job/124489303847", + "head_sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/41184756965/job/124489303847", + "id": 124489303847, + "name": "plan", + "status": "completed" + } + ], + "jobs": [ + { + "conclusion": "success", + "head_sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "id": 124489303847, + "name": "plan", + "status": "completed", + "steps": [ + { + "conclusion": "success", + "name": "Set up job", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Run actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Run actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Onboarding helper tests", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Select changed packages and declared input dependents", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Post Run actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Post Run actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1", + "status": "completed" + }, + { + "conclusion": "success", + "name": "Complete job", + "status": "completed" + } + ] + }, + { + "conclusion": "skipped", + "head_sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "id": 124490234925, + "name": "replay", + "status": "completed", + "steps": [] + } + ], + "method": "Read-only GitHub connector PR, exact-head workflow/check-run and selected run jobs metadata; no external writes, reruns, unrelated PRs, payloads or target tests.", + "observed_utc": "2026-10-31T08:34:30.267678+00:00", + "pr": { + "base": { + "ref": "main", + "repo": "CrocSwap/integer-mult-bounds", + "sha": "a7638a4ce2a29947457ae8d6bf8cd70a234dfeac" + }, + "body": "## Change and mathematical scope\n\nAdd an independently source-reviewed authentic-input loader, complete retained-value serializer consumer, and separate output validator under `research/h25-authentic-serializer-20261031/`. The package carries the exact original serializer/reference and controls plus all three authentic H25 input transports. This first incremental commit is a source proposal: controls and complete replay have not run, the execution envelope and parent admission remain pending, and O03 is not qualified. No caller, timing, memory, kappa or whole-goal gain is claimed.\n\n## Task and overlap\n\nExplicit user-directed continuation of the verification data-handling work. Base: `a7638a4ce2a29947457ae8d6bf8cd70a234dfeac`. Input provenance: PR #6029 at `e05aad954689d0ee21baff19b4674f1fcb2e838f`. Extends the bounded serializer extraction in #6326; #6328 is a separate inventory-only digest contribution. Scope is refined to authentic retained-value serialization, without fresh scientific construction or resuming paused cache/retention research.\n\n## Validation\n\nIndependent source review accepted the loader and its 39 ordered control cases per mode, and the complete consumer/independent validator with the unchanged 70 original plus 15 new consumer cases per mode. These are authored controls, not executed results. Independent export review checked all 51 files / 17,384,947 bytes, exact source copies, SHA256 and Git blob identities. Parent verified the three original input blob IDs and sizes in both upstream and fork.\n\nSee `README.md`, `TASK.json`, `loader/API-v1.md`, `consumer/README-v1.md`, the carried I1/I2 reviews, and the exact manifests. CLI forms describe interfaces only; a checkout or fabricated custody JSON is not an admitted run. Git modes do not preserve the required fresh immutable execution custody. Hosted planning, if successful, must be distinguished from replay.\n\n## Credit\n\nPreserves PR #6029, #6326 and their cumulative construction/reference/control provenance. Substantial implementation and independent source review assistance used GPT-6.1-sol agents at high effort. Existing source licensing and attribution are retained.\n\n## Open next questions\n\nComplete and independently review actual runtime/custody/observer/guard source and the exact fixed operation. Then run the original and new controls, one first full baseline and one first full candidate, and independent full-output validation under the existing 180-second / sampled 1-GiB limits. Preserve all failures and report inclusive costs and gain/no-gain/regression honestly. A later incremental evidence commit will record the resulting disposition; historical and final metadata/publication timing gaps remain OPEN_NOT_ZERO.\n", + "changed_files": 51, + "commits": 1, + "draft": true, + "head": { + "ref": "h25-authentic-serializer-20261031", + "repo": "Clear1nsight/integer-mult-bounds", + "sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725" + }, + "merged": false, + "number": 6332, + "state": "open", + "title": "Add authentic H25 serializer loader and independent validator sources", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/6332" + }, + "runs": [ + { + "conclusion": "success", + "created_at": "2026-10-31T08:28:37Z", + "event": "pull_request", + "head_sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "head_tree": "a1a971ba274f82480eaa83944f93470bbaf45d46", + "html_url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/41184756965", + "id": 41184756965, + "name": "Registered research packages", + "path": ".github/workflows/research-packages.yml", + "run_attempt": 1, + "status": "completed", + "updated_at": "2026-10-31T08:33:11Z" + } + ], + "schema": "o03-source-pr-readonly-evidence-v1", + "verification_errors": [] +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-PR-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-PR-REVIEW-v1.json new file mode 100644 index 0000000000..a6d51af7bc --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-PR-REVIEW-v1.json @@ -0,0 +1,37 @@ +{ + "base": "a7638a4ce2a29947457ae8d6bf8cd70a234dfeac", + "changed_files": 51, + "decision": "ACCEPT_SOURCE_PR_STATE", + "draft": true, + "evidence": { + "path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/SOURCE-PR-EVIDENCE-v1.json", + "sha256": "afc874457238b443001d847458e0d1c9ca6088de109fe942dc2c4f08aef9db34" + }, + "external_writes_or_target_tests": false, + "failures": [], + "head": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "hosted": { + "conclusion": "success", + "head": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "plan": { + "conclusion": "success", + "job": 124489303847 + }, + "replay": { + "conclusion": "skipped", + "job": 124490234925, + "steps": 0 + }, + "run": 41184756965, + "scope": "Hosted onboarding/planning success only; replay skipped, no authentic serializer/component/full-caller replay or runtime/O03 qualification.", + "status": "completed", + "url": "https://github.com/CrocSwap/integer-mult-bounds/actions/runs/41184756965" + }, + "later_evidence_commit": "Not part of this exact source-head observation; requires separate released export and fresh head review.", + "merged": false, + "observed_utc": "2026-10-31T08:34:30.267678+00:00", + "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/6332", + "schema": "o03-source-pr-review-v1", + "source_commit_count": 1, + "source_remote_review_sha256": "5ca5a19b5b70703686386afd281024e64f6b396888207788247a885e51203595" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-REMOTE-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-REMOTE-EVIDENCE-v1.json new file mode 100644 index 0000000000..52f475dbec --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-REMOTE-EVIDENCE-v1.json @@ -0,0 +1,526 @@ +{ + "commit": { + "message": "Add reviewed authentic H25 serializer loader and validator sources", + "parents": [ + { + "html_url": "https://github.com/Clear1nsight/integer-mult-bounds/commit/a7638a4ce2a29947457ae8d6bf8cd70a234dfeac", + "sha": "a7638a4ce2a29947457ae8d6bf8cd70a234dfeac", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/commits/a7638a4ce2a29947457ae8d6bf8cd70a234dfeac" + } + ], + "sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "tree": { + "sha": "a1a971ba274f82480eaa83944f93470bbaf45d46", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/a1a971ba274f82480eaa83944f93470bbaf45d46" + } + }, + "file_count": 51, + "files": [ + { + "mode": "100644", + "path": "consumer/bounded_serialization.py", + "sha": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "size": 23560, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/CONSUMER-CONTROL-SPEC-v1.json", + "sha": "cab48c3a31b095e78253899bff95548e44a32e6f", + "size": 736, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/CONTROL-SPEC.json", + "sha": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "size": 3062, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/DEPENDENCIES-v1.json", + "sha": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "size": 3934, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/full_consumer.py", + "sha": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "size": 9411, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/PACKAGE-PINS-v1.json", + "sha": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "size": 2453, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/PASSIVE-ATTEMPTS-v1.json", + "sha": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "size": 719, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/PASSIVE-CHECKS-v1.json", + "sha": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "size": 2637, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/README-v1.md", + "sha": "8879b820a9c05c78857964f0674ae4c4806a7726", + "size": 6609, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/reference.py", + "sha": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "size": 2141, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/run_controls.py", + "sha": "1926eb081f24a953f1521ee63555fe7910a26e05", + "size": 6630, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/serialization_controls.py", + "sha": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "size": 23684, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/SOURCE-READINESS-v1.json", + "sha": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "size": 2081, + "type": "blob" + }, + { + "mode": "100644", + "path": "consumer/validate_outputs.py", + "sha": "ade0aa6b46e28531797062f73b664efc8705f445", + "size": 14577, + "type": "blob" + }, + { + "mode": "100644", + "path": "inputs/baseline/evidence/canonical/complex-network.json", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "size": 5662, + "type": "blob" + }, + { + "mode": "100644", + "path": "inputs/baseline/evidence/canonical/rank-trace.json.gz", + "sha": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "size": 22029, + "type": "blob" + }, + { + "mode": "100644", + "path": "inputs/baseline/evidence/canonical/witness.json.gz", + "sha": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "size": 16995263, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/API-v1.md", + "sha": "ec051bd35aad548258708278b146a037908a7dfa", + "size": 5012, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/CONTROL-SPEC-v1.json", + "sha": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "size": 2002, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/frozen_h25_inputs.py", + "sha": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "size": 14650, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/frozen_input_controls.py", + "sha": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "size": 13181, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/PACKAGE-PINS-v1.json", + "sha": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "size": 1152, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/PASSIVE-ATTEMPTS-v1.json", + "sha": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "size": 586, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/SOURCE-PINS-v1.json", + "sha": "b584cb6cdee15071f76918e1055a224000c5f255", + "size": 2395, + "type": "blob" + }, + { + "mode": "100644", + "path": "loader/SOURCE-READINESS-v1.json", + "sha": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "size": 2306, + "type": "blob" + }, + { + "mode": "100644", + "path": "PACKAGE-MANIFEST-v1.json", + "sha": "6889471d578aa766d0929510cbf9aa5ae2f8157c", + "size": 14454, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json", + "sha": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "size": 2945, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/feasibility/contract/DECISION-v1.json", + "sha": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "size": 9046, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/feasibility/contract/O03-MATRIX-v1.json", + "sha": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "size": 18742, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/feasibility/review/REVIEW-v1.json", + "sha": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "size": 10656, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/feasibility/technical/FEASIBILITY-v1.json", + "sha": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "size": 11462, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/feasibility/technical/PROBE-SPEC-v1.json", + "sha": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "size": 11830, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/feasibility/technical/SOURCE-PINS-v1.json", + "sha": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "size": 12719, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/implementation/control/AUTHORIZATION-v1.json", + "sha": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "size": 1169, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json", + "sha": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "size": 3351, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/implementation/PLAN-v1.md", + "sha": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "size": 6135, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-goal/control/hourly-progress/RUBRIC-v1.json", + "sha": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "size": 6249, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-goal/control/PLAN-before-granular-progress-v1.md", + "sha": "97b016c958d3e309ef884213fda3328388f69e58", + "size": 14285, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-serializer/ORIGINAL-SOURCE-PINS.json", + "sha": "1767b5809d01af10dd64eb528b37f22049c53734", + "size": 3032, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-serializer/provenance/compare_side_verifier.py", + "sha": "d94920c274c0a47db9763dd595230d52df0bd073", + "size": 10571, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-serializer/provenance/native_backend.py", + "sha": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "size": 20334, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-serializer/provenance/profile_side_verifier.py", + "sha": "807855eb875673c47da0ed1b5a890a417e28a846", + "size": 8959, + "type": "blob" + }, + { + "mode": "100644", + "path": "provenance/original-serializer/REFERENCE-EXTRACTION.json", + "sha": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "size": 2031, + "type": "blob" + }, + { + "mode": "100644", + "path": "README.md", + "sha": "9d107621005d53d443c9572c31b6df78656fe225", + "size": 5174, + "type": "blob" + }, + { + "mode": "100644", + "path": "reviews/I1-EVIDENCE-v1.json", + "sha": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "size": 2211, + "type": "blob" + }, + { + "mode": "100644", + "path": "reviews/I1-REVIEW-v1.json", + "sha": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "size": 5166, + "type": "blob" + }, + { + "mode": "100644", + "path": "reviews/I2-EVIDENCE-v1.json", + "sha": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "size": 5912, + "type": "blob" + }, + { + "mode": "100644", + "path": "reviews/I2-REVIEW-v1.json", + "sha": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "size": 4600, + "type": "blob" + }, + { + "mode": "100644", + "path": "SOURCES-EXPORT-v1.json", + "sha": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "size": 23776, + "type": "blob" + }, + { + "mode": "100644", + "path": "SOURCES.json", + "sha": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "size": 1951, + "type": "blob" + }, + { + "mode": "100644", + "path": "TASK.json", + "sha": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "size": 1715, + "type": "blob" + } + ], + "named_subtree_queries": [ + { + "entries": 14, + "name": "consumer", + "sha": "3f1c5435bc429c5b326edce457bccf74c4434a1a", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/3f1c5435bc429c5b326edce457bccf74c4434a1a?recursive=1" + }, + { + "entries": 6, + "name": "inputs", + "sha": "1e3d584deb5514157cf3820a99f6480a82982a6e", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/1e3d584deb5514157cf3820a99f6480a82982a6e?recursive=1" + }, + { + "entries": 8, + "name": "loader", + "sha": "a36dcc3de6c41f8488793482a68e821cdd548b08", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/a36dcc3de6c41f8488793482a68e821cdd548b08?recursive=1" + }, + { + "entries": 28, + "name": "provenance", + "sha": "fad414e1908f7d87d67cd921fc6f3c9e6c520c3b", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/fad414e1908f7d87d67cd921fc6f3c9e6c520c3b?recursive=1" + }, + { + "entries": 4, + "name": "reviews", + "sha": "b8e0fccb733bb3a17fbe6374639f8af736b4d71d", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/b8e0fccb733bb3a17fbe6374639f8af736b4d71d?recursive=1" + } + ], + "network_method": "Read-only GitHub connector metadata. Root/research tree traversal was nonrecursive solely to bind named package tree; only named package subtrees fetched recursively. No blob payload downloads, target execution or decode.", + "package_tree": { + "sha": "8246a82027ee9149063dd97f00c311f57efb2088", + "tree": [ + { + "mode": "100644", + "path": "PACKAGE-MANIFEST-v1.json", + "sha": "6889471d578aa766d0929510cbf9aa5ae2f8157c", + "size": 14454, + "type": "blob", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/blobs/6889471d578aa766d0929510cbf9aa5ae2f8157c" + }, + { + "mode": "100644", + "path": "README.md", + "sha": "9d107621005d53d443c9572c31b6df78656fe225", + "size": 5174, + "type": "blob", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/blobs/9d107621005d53d443c9572c31b6df78656fe225" + }, + { + "mode": "100644", + "path": "SOURCES-EXPORT-v1.json", + "sha": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "size": 23776, + "type": "blob", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/blobs/435ba23c03c4dda2c98807c5c8bcc18c36db32d4" + }, + { + "mode": "100644", + "path": "SOURCES.json", + "sha": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "size": 1951, + "type": "blob", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/blobs/a8e576f93e1ec30c5d7a4fa0284243bd870aef69" + }, + { + "mode": "100644", + "path": "TASK.json", + "sha": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "size": 1715, + "type": "blob", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/blobs/df9d7b6886c6430cc5e36971738ad241d9e27beb" + }, + { + "mode": "040000", + "path": "consumer", + "sha": "3f1c5435bc429c5b326edce457bccf74c4434a1a", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/3f1c5435bc429c5b326edce457bccf74c4434a1a" + }, + { + "mode": "040000", + "path": "inputs", + "sha": "1e3d584deb5514157cf3820a99f6480a82982a6e", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/1e3d584deb5514157cf3820a99f6480a82982a6e" + }, + { + "mode": "040000", + "path": "loader", + "sha": "a36dcc3de6c41f8488793482a68e821cdd548b08", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/a36dcc3de6c41f8488793482a68e821cdd548b08" + }, + { + "mode": "040000", + "path": "provenance", + "sha": "fad414e1908f7d87d67cd921fc6f3c9e6c520c3b", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/fad414e1908f7d87d67cd921fc6f3c9e6c520c3b" + }, + { + "mode": "040000", + "path": "reviews", + "sha": "b8e0fccb733bb3a17fbe6374639f8af736b4d71d", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/b8e0fccb733bb3a17fbe6374639f8af736b4d71d" + } + ], + "truncated": false + }, + "ref": { + "object": { + "sha": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "type": "commit", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/commits/bc88937088bdd9f4f71fbdc9246dbf58b11eb725" + }, + "ref": "refs/heads/h25-authentic-serializer-20261031" + }, + "repository": "Clear1nsight/integer-mult-bounds", + "research_nonrecursive_path": { + "entries_observed": 4985, + "package": { + "mode": "040000", + "path": "h25-authentic-serializer-20261031", + "sha": "8246a82027ee9149063dd97f00c311f57efb2088", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/8246a82027ee9149063dd97f00c311f57efb2088" + }, + "sha": "e7cdf81233e36b4ebfbb9412b7ef2bc8c13cf768", + "truncated": false, + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/e7cdf81233e36b4ebfbb9412b7ef2bc8c13cf768" + }, + "root_tree": { + "research": { + "mode": "040000", + "path": "research", + "sha": "e7cdf81233e36b4ebfbb9412b7ef2bc8c13cf768", + "type": "tree", + "url": "https://api.github.com/repos/Clear1nsight/integer-mult-bounds/git/trees/e7cdf81233e36b4ebfbb9412b7ef2bc8c13cf768" + }, + "sha": "a1a971ba274f82480eaa83944f93470bbaf45d46" + }, + "schema": "o03-source-remote-readonly-evidence-v1", + "total_bytes": 17384947, + "verification_errors": [] +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-REMOTE-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-REMOTE-REVIEW-v1.json new file mode 100644 index 0000000000..accc77418e --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/SOURCE-REMOTE-REVIEW-v1.json @@ -0,0 +1,26 @@ +{ + "PR_and_hosted_checks": "PENDING parent PR ID; no claims about hosted replay.", + "all_remote_blob_SHA_size_mode_match": true, + "base_parent": "a7638a4ce2a29947457ae8d6bf8cd70a234dfeac", + "branch": "h25-authentic-serializer-20261031", + "decision": "ACCEPT", + "evidence": { + "path": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/publication/SOURCE-REMOTE-EVIDENCE-v1.json", + "sha256": "cddbcb07d6edb29d11c8b167d76aa43f3522522a6c96e46e96ec62a71ec1376f" + }, + "execution_or_O03_qualification": false, + "export_freeze_sha256": "5db374e8e9f8b69e574b2b24c4f4f3b8135927fbc044f1a2e7d3722ed05976f6", + "failures": [], + "head": "bc88937088bdd9f4f71fbdc9246dbf58b11eb725", + "network_writes": 0, + "package_path": "research/h25-authentic-serializer-20261031", + "package_tree": "8246a82027ee9149063dd97f00c311f57efb2088", + "remote_identity_boundary": "Remote Git blob SHA1 and size/mode match the independently accepted frozen local bytes/SHA256. No binary payload re-download or runtime custody claim.", + "repository": "Clear1nsight/integer-mult-bounds", + "schema": "o03-source-remote-review-v1", + "scope": "Independent read-only remote publication identity review only; relies on separately accepted source/export review.", + "target_tests_imports_decodes": 0, + "tree": "a1a971ba274f82480eaa83944f93470bbaf45d46", + "verified_bytes": 17384947, + "verified_files": 51 +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-publication/TREE-ENTRIES-v1.json b/research/h25-authentic-serializer-20261031/validation/source-publication/TREE-ENTRIES-v1.json new file mode 100644 index 0000000000..aa5d7c33ec --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-publication/TREE-ENTRIES-v1.json @@ -0,0 +1,311 @@ +{ + "entries": [ + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/PACKAGE-MANIFEST-v1.json", + "sha": "6889471d578aa766d0929510cbf9aa5ae2f8157c", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/README.md", + "sha": "9d107621005d53d443c9572c31b6df78656fe225", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/SOURCES-EXPORT-v1.json", + "sha": "435ba23c03c4dda2c98807c5c8bcc18c36db32d4", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/SOURCES.json", + "sha": "a8e576f93e1ec30c5d7a4fa0284243bd870aef69", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/TASK.json", + "sha": "df9d7b6886c6430cc5e36971738ad241d9e27beb", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json", + "sha": "cab48c3a31b095e78253899bff95548e44a32e6f", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/CONTROL-SPEC.json", + "sha": "38c8aaa25b89f07f0290dac9fe89ddab32c31ab3", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/DEPENDENCIES-v1.json", + "sha": "b864f9a83a39ff922f5a43b19453c24c4485bba4", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/PACKAGE-PINS-v1.json", + "sha": "e902ca311a97cebf43eaaf5af859a7c8760e2d13", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/PASSIVE-ATTEMPTS-v1.json", + "sha": "c8d59bad78a5d397d54e18fd2988830c536b245c", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/PASSIVE-CHECKS-v1.json", + "sha": "6a2e816cf9f0e5e16c73e7bb9c7fb7601403c2fd", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/README-v1.md", + "sha": "8879b820a9c05c78857964f0674ae4c4806a7726", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/SOURCE-READINESS-v1.json", + "sha": "702c8ac557cf87b9343d862aff1c1e707f2ec58c", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/bounded_serialization.py", + "sha": "70c4587a67a9f11f87dcc333b3cc84c4b17de773", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/full_consumer.py", + "sha": "f1ee20919429eed8a47a4c7a37f7da204e8cd015", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/reference.py", + "sha": "2c60da3ae8dc72c4ac2886a11a76c5fbad8f0c8a", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/run_controls.py", + "sha": "1926eb081f24a953f1521ee63555fe7910a26e05", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/serialization_controls.py", + "sha": "7ace093a93a93c3ba1cf3c73b8bf8764ab7e51a4", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/consumer/validate_outputs.py", + "sha": "ade0aa6b46e28531797062f73b664efc8705f445", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/complex-network.json", + "sha": "62a6091887a3894535c1d059e1b0c527d556eb76", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/rank-trace.json.gz", + "sha": "8b071cc72553c3b51d1d8b1aa3daeb530ca396d5", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/inputs/baseline/evidence/canonical/witness.json.gz", + "sha": "4d7d6a59c70839517c3b42587d9699c1e6850f4a", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/API-v1.md", + "sha": "ec051bd35aad548258708278b146a037908a7dfa", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/CONTROL-SPEC-v1.json", + "sha": "dc7ba9e274d918a24058aa4d798638c29d03af13", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/PACKAGE-PINS-v1.json", + "sha": "0349985c4363c42285437f3f3c0c6067ee75fbb9", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/PASSIVE-ATTEMPTS-v1.json", + "sha": "75850f7bb3f1a9a18fac05eaffcb90fa187f518f", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/SOURCE-PINS-v1.json", + "sha": "b584cb6cdee15071f76918e1055a224000c5f255", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/SOURCE-READINESS-v1.json", + "sha": "13057e90237ce3d4fdb5035a0afa519507a8b1ae", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/frozen_h25_inputs.py", + "sha": "f81eff3319121c8d891e3b8c23b38cb45c3a60f8", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/loader/frozen_input_controls.py", + "sha": "6bae29c38e1e5e9639147121cf2e0dfba6cdf94e", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/AUTHENTIC-TRANSPORT-GIT-PINS-v1.json", + "sha": "4f28ce349e3bd862c99100e0b5e188df48b3ff62", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/feasibility/contract/DECISION-v1.json", + "sha": "ac2ae0ebb3283f908e2e41bf06a62b454a0ef830", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/feasibility/contract/O03-MATRIX-v1.json", + "sha": "9eb362b236bd2c61b3be6a555c99b5b8076850cd", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/feasibility/review/REVIEW-v1.json", + "sha": "c84f737f31f24fbe97cce2b044491ba97a21c865", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/feasibility/technical/FEASIBILITY-v1.json", + "sha": "5aace52e8d1558bc2d32081926a9612020f19cf1", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/feasibility/technical/PROBE-SPEC-v1.json", + "sha": "eb71ccf04635e1fbf8086e951bf7e208c58aeab1", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/feasibility/technical/SOURCE-PINS-v1.json", + "sha": "d3a9c3844b0ea7b83700cce14958d9708ce726cc", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/implementation/PLAN-v1.md", + "sha": "e24ed3595ccf9452ad4cf7b5dd449ef9cf382941", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/implementation/control/AUTHORIZATION-v1.json", + "sha": "f90b3903b7e94d016e250220dc1ab22105e92fa9", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/implementation/control/REMOTE-INPUT-OBJECTS-v1.json", + "sha": "6b6e19c6880ba9536d2e6e7f9f3e44da6ca78899", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-goal/control/PLAN-before-granular-progress-v1.md", + "sha": "97b016c958d3e309ef884213fda3328388f69e58", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-goal/control/hourly-progress/RUBRIC-v1.json", + "sha": "5d78a242050d29ae025dc7a35890dbd1aa3d4e49", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-serializer/ORIGINAL-SOURCE-PINS.json", + "sha": "1767b5809d01af10dd64eb528b37f22049c53734", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-serializer/REFERENCE-EXTRACTION.json", + "sha": "8a7e774b8e10f1045a4c464781f1b748e0e0280f", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/compare_side_verifier.py", + "sha": "d94920c274c0a47db9763dd595230d52df0bd073", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/native_backend.py", + "sha": "77e55ce9d0afb48f220f6e7416437562b41b67d3", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/provenance/original-serializer/provenance/profile_side_verifier.py", + "sha": "807855eb875673c47da0ed1b5a890a417e28a846", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/reviews/I1-EVIDENCE-v1.json", + "sha": "6a8dbea6a39489da9bbf5b460243d732e0bf2998", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/reviews/I1-REVIEW-v1.json", + "sha": "c1a98b876a2fc05ea28ccda4e0daa13a3bedbf9f", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/reviews/I2-EVIDENCE-v1.json", + "sha": "23621cd1ca7faefdbe2d0a5bb82c73dc50759836", + "type": "blob" + }, + { + "mode": "100644", + "path": "research/h25-authentic-serializer-20261031/reviews/I2-REVIEW-v1.json", + "sha": "6420292636e2688fbc615c59dc5eadd7d94b1f26", + "type": "blob" + } + ], + "schema": "o03-source-git-tree-entries-v1" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/COMBINED-SOURCE-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/COMBINED-SOURCE-REVIEW-v1.json new file mode 100644 index 0000000000..00099b55c2 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/COMBINED-SOURCE-REVIEW-v1.json @@ -0,0 +1,16 @@ +{ + "I4": "NOT_PRESENT_FOR_REVIEW; exact concrete parent admission/current ledger/native command/readback binding is next required object", + "O03_qualified": false, + "accepted_lanes": { + "I1": "I1-REVIEW-v1.json", + "I2": "I2-REVIEW-v1.json", + "I3": "I3-REVIEW-v2.json" + }, + "controller_and_tail_costs": "Explicit finite outside-core OPEN_NOT_ZERO retained; later I7 must independently assess exact unchanged-O03 qualification scope.", + "created_utc": "2026-10-31T08:29:22.389043+00:00", + "decision": "ACCEPT_SOURCE_DEPENDENCY_CLOSURE", + "exact_fixed_prospective_operation": "One180s complete-fixed-o03 sequence,39/70+15 normal/-O,6observer controls, first complete baseline/candidate plus independent complete validator; original Q1-Q5/P0-P5 unchanged.", + "execution_admitted": false, + "no_conditional_source_milestones": "All3 complete precise source lanes accepted; none imply executed evidence or actual runtime/custody/control/cap admission.", + "schema": "o03-integrated-source-dependency-review-v1" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/FAILURE-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/FAILURE-EVIDENCE-v1.json new file mode 100644 index 0000000000..567636a497 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/FAILURE-EVIDENCE-v1.json @@ -0,0 +1,97 @@ +{ + "all13_retained_files_hashed": true, + "arithmetic": { + "attempt_policy_seconds": "0.34", + "outer_wall_seconds": "0.33", + "predeclared_rounding_seconds": "0.01", + "prior_policy_seconds": "94.210533479", + "total_policy_seconds": "94.550533479" + }, + "consumed_admission_sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "created_utc": "2026-10-31T08:43:28.329574+00:00", + "files": { + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/complete-fixed-o03/observer-receipt.json": { + "bytes": 2046, + "mode_octal": "0o444", + "sha256": "5258f2c2132f3438497c41116300f52dca6409f021b73025928c84e0b4918652" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json": { + "bytes": 2540, + "mode_octal": "0o444", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/EXEC-RESULT-v1.json": { + "bytes": 126, + "mode_octal": "0o444", + "sha256": "156917ce5281901a1a08ed1c98093e9c9fd361c28cf135863ffe27f4c0e0e01c" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/FAILURE-v1.json": { + "bytes": 1130, + "mode_octal": "0o444", + "sha256": "6f5381223a2cf6fb68fda081ecb723688c9237127865d397284ca6f3c585fc2b" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/I4-PACKET-v1.json": { + "bytes": 1335, + "mode_octal": "0o444", + "sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LAUNCH-v1.json": { + "bytes": 581, + "mode_octal": "0o444", + "sha256": "92c8ee7129be80dd54ac8156a1b7a184344c53b44b845602f33cba6bfa03acf2" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-001.json": { + "bytes": 2406, + "mode_octal": "0o444", + "sha256": "589b607e096d4ef7a49b38501827f1f5b865d1263591dff8b96cded9c7d62126" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json": { + "bytes": 4139, + "mode_octal": "0o444", + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-COMMAND-v1.json": { + "bytes": 2909, + "mode_octal": "0o444", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-EXEC-RESULT-v1.json": { + "bytes": 1583, + "mode_octal": "0o444", + "sha256": "f3e03d0875879b0dc3316bc1e5b34ea28be8d3c8600587320422c50e222e10cf" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json": { + "bytes": 33047, + "mode_octal": "0o444", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-consumed": { + "bytes": 65, + "mode_octal": "0o444", + "sha256": "2a928d004026b4f90440b2cc970c2a851726e23c413d0dac086384f07e931c4c" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/outer-time.json": { + "bytes": 148, + "mode_octal": "0o444", + "sha256": "a5435c2c21b838555a1c8201831cbab5ccef5c3dd0120972078c86d8a110fdfa" + } + }, + "ledger_bound_refs_exact": true, + "method": "Passive retained evidence/source/metadata/hash/Decimal arithmetic only; no actual process/target/probe/tests/imports", + "missing_locale_dependency_in_current_manifest": true, + "observer_has_execution_field": false, + "only_operation_file": "observer-receipt.json", + "parent_readback_report_exists": false, + "raw_outer_JSON_records": 1, + "raw_outer_diagnostic_lines": 1, + "raw_outer_timing": { + "exit": 1, + "kernel_individual_maxrss_kib": 19392, + "system_seconds": 0.06, + "user_seconds": 0.26, + "wall_seconds": 0.33 + }, + "reaped_child_CPU_seconds": 0, + "schema": "o03-independent-first-attempt-failure-evidence-v1", + "source_v2_all19members_unchanged": true +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/FAILURE-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/FAILURE-REVIEW-v1.json new file mode 100644 index 0000000000..0a73cb6559 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/FAILURE-REVIEW-v1.json @@ -0,0 +1,113 @@ +{ + "O03_qualification_decision": "REJECT_NO_QUALIFYING_EXECUTED_EVIDENCE", + "activity_boundary_reviewer": { + "decompressions": 0, + "method": "Passive retained source/evidence JSON/text/hash/metadata and exact Decimal arithmetic only", + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_calls": 0, + "target_imports": 0, + "tests_controls_benchmarks": 0 + }, + "created_utc": "2026-10-31T08:45:07.233513+00:00", + "current_checkpoint_adjudication": { + "I1": { + "current": "ACCEPT_SOURCE_SCOPE", + "reason": "Exact isolated loader/control source unchanged; no runtime results claimed." + }, + "I2": { + "current": "ACCEPT_SOURCE_SCOPE", + "reason": "Exact consumer/validator/control source unchanged; no runtime results claimed." + }, + "I3": { + "current": "INVALIDATED_KNOWN_INCOMPLETE_NOT_CURRENTLY_ACCEPTED", + "historical": "SOURCE_ACCEPTANCE_RECORD_PRESERVED_UNCHANGED", + "reason": "Actual locale-data dependency closure incomplete and nonzero-exit closing readback contract broken; this exact current envelope is not known-operable and cannot retain current I3 passed credit." + }, + "I4": { + "current": "CONSUMED_FAILED_CLOSED_NO_CURRENT_OPERABLE_ADMISSION_OR_PASSED_CREDIT", + "historical": "EXACT_ONCE_ONLY_AUTHORIZATION_REVIEW_PRESERVED_UNCHANGED", + "reason": "Exact authorized attempt was made and failed its first runtime precondition; grant is consumed and cannot be reused. Dispatch was historically authorized, not retroactively unauthorized." + }, + "I5": { + "controls_executed": 0, + "current": "UNQUALIFIED_NOT_REACHED" + }, + "I6": { + "current": "UNQUALIFIED_NOT_REACHED", + "full_arms_executed": 0, + "validator_executed": 0 + }, + "I7": { + "current": "UNQUALIFIED_REJECT_NO_FULL_ARTIFACT_MEMORY_COST_EVIDENCE", + "measured_gain": null + }, + "I8": "Separate publication/delivery review; no I8 passed decision made here", + "current_valid_source_checkpoints": 2, + "historical_accepted_high_water": 4, + "new_positive_checkpoint_credit_from_this_review": 0, + "no_progress_timer_rule": "Preserve last genuine new higher accepted checkpoint timestamp/high-water record. Negative outcome acceptance/current credit invalidation grants no new passed checkpoint and does not reset the no-progress clock. Hard original round deadline remains09:04:36.048558UTC." + }, + "decision": "ACCEPT_RETAINED_FAILURE_ATTRIBUTION_AND_SCOPED_POLICY_ACCOUNTING", + "evidence": "FAILURE-EVIDENCE-v1.json", + "failure_packet_sha256": "6f5381223a2cf6fb68fda081ecb723688c9237127865d397284ca6f3c585fc2b", + "first_attempt": { + "admission_sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "automatic_or_manual_retries": 0, + "consumed_marker_exact": true, + "declared_parent_readback_attempts": 1, + "declared_parent_readback_exit": 1, + "dispatches": 1, + "historically_independently_admitted": true, + "operation_exit": 1, + "postfailure_source_changes": 0 + }, + "future_minimum_repairs_DIAGNOSTIC_ONLY_NOT_AUTHORIZED": [ + "A new independently reviewed runtime/provider/source packet must seal the actual locale-archive dependency and its exact metadata/hash/mapped-file allowance for the intended fixed environment, or establish a separately reviewed deterministic locale policy with its complete actual closure. This observed missing map is one diagnosed gap; adding it is not proof of all future closure or permission to retry.", + "A new closing protocol must preserve bounded machine-readable timing and structured failure handling for nonzero/signal/malformed records, including GNUtime diagnostic prefixes. Preserve raw diagnostics; exercise source-frozen zero/nonzero/error-format controls only under future explicit admission.", + "Revalidate any new source/runtime/command/custody/bill and issue fresh independently reviewed one-use admission in a newly authorized round. Existing one source repair is already used; no edit, rerun, speculative probe or new execution is authorized here." + ], + "ledger_sha256": "589b607e096d4ef7a49b38501827f1f5b865d1263591dff8b96cded9c7d62126", + "policy_accounting": { + "attempt_policy_seconds": "0.34", + "decision": "ACCEPT_AS_SCOPED_CANONICAL_POLICY_DEBIT_ONLY", + "observer_parent_CPU_seconds": "0.305745", + "observer_reaped_children_CPU_seconds": "0", + "outside_boundary": "Native controller instrumentation, observer final write, failed declared readback, manual accounting/adjudication/report/publication and historical costs remain OPEN_NOT_ZERO. No all-physical-cost or all-guard-CPU closure claimed.", + "physical_total_seconds": null, + "predeclared_rounding_quantum_seconds": "0.01", + "prior_policy_seconds": "94.210533479", + "raw_GNUtime_CPU_seconds_reported": "0.32", + "raw_GNUtime_wall_seconds": "0.33", + "raw_outer_exit": 1, + "raw_tool_wall_metadata": "EXEC-RESULT wall_time_seconds is retained tool telemetry; not substituted for or added to predeclared GNUtime policy wall.", + "updated_policy_seconds": "94.550533479", + "upper_cap_fit": "This failed startup command stayed below180s/600s/2400s policy bounds; this is not full-route resource-fit evidence." + }, + "primary_failure": { + "actual_error": "unsealed mapped files: ['/usr/lib/locale/locale-archive']", + "attribution": "Observer initial runtime closure before constructing/launching the sequence worker rejected an actual locale-data mapping absent from both pinned runtime files and permitted mapped_files. This is a real missing actual-runtime dependency for this fixed host/source command; it is not evidence that a scientific value/output/schema changed.", + "boundary": "Observer/bootstrap/custody/effective/stdlib startup and authentication code ran. No I1/I2 target control/loader/consumer/validator function or scientific/native computation ran.", + "source_location": "envelope/revision-v2/envelope/bootstrap.py closure actual_maps subset check; observer.py initial observer_runtime_before", + "support": "Observer STOP repeats identical primary/after-runtime error, has no execution field, reports0 reaped-child CPU, and operation directory contains only observer-receipt.json. All19 frozen v2 source members remain exact. No worker/staged package/authentic input copies/control/full-output artifacts exist." + }, + "publication_scope": "A portable second evidence commit may carry the exact failed attempt/source/runtime/readback packet, immutable raw records, historical I3/I4 acceptances and this current invalidation/negative qualification. Label the failed envelope known incomplete/not admitted and retain first source-export history. No successful controls/replay, gain, O03, original caller, historical physical closure or whole-goal claim is supported.", + "resource_observations": { + "GNUtime_kernel_individual_maxRSS_KiB": 19392, + "cgroup_peak": "NOT_COLLECTED", + "gain": "NOT_MEASURED_NO_BASELINE_CANDIDATE_COMPARISON", + "interpretation": "Scoped failed-startup observations only. Samples and individual kernel high water marks are separate quantities, neither is full-data/arm/writer memory evidence. No observed cap excess in these retained records; genuine eager loading/writer fit was never exercised.", + "observer_individual_maxRSS_KiB": 19392, + "sampled_simultaneous_observer_tree_RSS_bytes": 19726336, + "sampler_errors": [], + "samples": 24 + }, + "schema": "o03-independent-first-fixed-operation-failure-review-v1", + "secondary_failure": { + "actual_raw_format": "One GNUtime nonzero diagnostic line followed by one JSON timing line,148 retained bytes.", + "attribution": "Declared parent_readback.py reads the entire outer-time file through json.loads before initializing its structured report. The leading Command exited with non-zero status1 line causes JSONDecodeError at line1column1; tool traceback identifies parent_readback.py:21 and custody.py:69. No parent-readback.json exists.", + "disposition": "Raw bytes and failed readback tool result retained unchanged. Parent separate bounded manual accounting extraction does not turn the declared readback into PASS and is not a rerun or repaired target." + } +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-REVIEW-v1.json new file mode 100644 index 0000000000..37b1e7056e --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-REVIEW-v1.json @@ -0,0 +1,50 @@ +{ + "accepted_checkpoint": null, + "activity_boundary": { + "decompressions": 0, + "method": "Passive text/AST/hash/metadata only", + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_calls": 0, + "target_imports": 0, + "tests_controls_benchmarks": 0 + }, + "additional_source_requirement": { + "failure": "Full consumer imports only reference at module scope; loader and bounded_serialization imports occur inside run after effective_before capture. unchanged compares only names present before, leaving actual loader/candidate module functions without before effective-binding seal.", + "file": "bootstrap.py main effective_before", + "id": "I3-R2", + "required_fix": "Seal per-entry/per-arm actual package dependencies before effective_before (loader for both arms, candidate for candidate) while retaining validator process import independence, or implement equivalent immediate before-call seal. No live origin/provider success inferred from source." + }, + "counterexample": { + "file": "ADMISSION-TEMPLATE-v1.json package_sources", + "id": "I3-R1", + "proof_method": "Passive manifest key absence plus exact accepted consumer source read; no target imports/calls performed.", + "required_fix": "Add exact frozen consumer/CONTROL-SPEC.json. Also retain consumer/CONSUMER-CONTROL-SPEC-v1.json and loader/CONTROL-SPEC-v1.json in declared control-spec stage closure and recompute source/bill/pins.", + "severity": "DECISIVE_SOURCE_CLOSURE_FAILURE", + "smallest_failure": "consumer/run_controls.py:44 unconditionally reads HERE/CONTROL-SPEC.json, absent from23-file staged package_sources; FileNotFoundError occurs before original70 controls.", + "trigger": "Use exact frozen template source map to stage package, then follow fixed consumer-controls-normal job." + }, + "created_utc": "2026-10-31T08:21:17.165202+00:00", + "decision": "REJECT", + "disposition": "Preserve complete originalv1 source snapshots and rejection. No execution admitted. Any parent-authorized single source repair requires a new exact frozen review; no accepted milestone or progress credit from this rejection.", + "execution_admitted": false, + "finite_measurement_boundary": { + "core": "GNUtime begins before sole observer Python startup and records complete wall/CPU plus kernel individual maxRSS; explicitly unsampled startup interval is disclosed; continuous10ms group sampling starts before admission/auth/staging and covers all substantive closes. No exact continuous concurrent peak requirement imposed.", + "decision": "ACCEPTABLE_PROTOCOL_WITH_EXACT_PARENT_BINDING_STILL_REQUIRED", + "no_recursion": "No observer-of-observer infinite closure demanded; sampling/PID/reparenting limits explicit.", + "outside_tail": "One final observer write, one parent metadata readback, ledger reconciliation/independent adjudication/publication finite OPEN_NOT_ZERO. No substantive serialization/control/validation/cleanup omitted.", + "parent_readback_requirements": "Single finite final readback rejects incomplete/failed records and any outer individual maxRSS>1GiB; canonical charge must include complete outer wall rather than only observer elapsed excluding startup. Native time/timeout binary/provider pins and exact immutable source/admission/current ledger binding required at I4." + }, + "lane": "I3", + "preserved_nondefects": [ + "Fixed unchanged O03 scope, old70 normal/-O plus39 loader/15 consumer and6 observer source cases, genuine baseline/candidate and separate validator remain correct intended fixed sequence.", + "-S bypasses system site/.pth; source-bound paid tempfile initialization resolves legitimate lazy cache rebind gap.", + "Built-in zlib provider,linked libz and selected native JSON/hash runtime identities are prospective checked predicates, not falsely reported observed.", + "No unrelated O08/global O09 prerequisite added. I1/I2 source and exact source-proposal export acceptances unaffected." + ], + "schema": "o03-independent-I3-source-review-v1", + "source_evidence": "I3-v1-EVIDENCE.json", + "source_snapshot": "I3-v1-source-snapshot" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-REVIEW-v2.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-REVIEW-v2.json new file mode 100644 index 0000000000..6257939348 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-REVIEW-v2.json @@ -0,0 +1,73 @@ +{ + "I4_exact_parent_requirements": [ + "Fresh independently pinned concrete admission with no administrative placeholders and fixed sequence/pins unchanged; actual observer/worker/source paths and immutable custody bindings.", + "Complete current canonical ledger/policy/prior-attempt inventory and existing canonical lock; reconcile unclosed attempts, record full outer charge after any outcome. No new allowance.", + "Exact absolute env-i/timeout/GNUtime/Python-B-I-S command, fresh operation/consumed/outer/readback paths; one finite exact parent readback command.", + "Carry explicit controller-instrumentation OPEN_NOT_ZERO outside-core boundary and final-tail costs in admission/readback/qualification; no all-guard-measured claim." + ], + "accepted_checkpoint": "I3", + "accepted_finite_measurement_boundary": { + "RSS": "10ms sampled simultaneous observer+discoverable-descendant RSS through all substantive core closes; initial observer import window unsampled and sampling/PID/short-lived/reparenting/shared-page limitations explicit; GNUtime kernel individual maxRSS separately bounded; no exact true group peak, sum-of-individual-peaks or cgroup claim.", + "canonical_charge": "Parent readback rejects incomplete/failed observer or outer records, outer individual maxRSS>1GiB, samplecap/error/absence, full command>180s and aggregate>2400s; charge full GNUtime outer wall+0.01s rounding quantum, never inner observer timer only.", + "controller_instrumentation": "Fixed native env/timeout/GNUtime controller startup/prefix/CPU/RSS overhead is outside observer-descendant core and remains OPEN_NOT_ZERO, as explicitly resolved with parent. Do not claim all guard/controller CPU or RSS measured. Exact native17file provider pins retained. No recursive observer requirement imposed.", + "included_core": "Observer+all waited descendants from GNUtime before observer Python startup, source/runtime authentication, copies/staging, imports/tempfile setup, all controls, complete eager loader restoration, baseline/candidate, independent validation, receipts/log/readbacks and success/failure cleanup through declared core endpoint.", + "qualification_limit": "This finite cost boundary is eligible for exact later I7 assessment; source/core PASS does not itself prove unchanged-O03 cost-evidence qualification or close historical/global costs.", + "tail": "One final observer record write and one finite parent readback/report; canonical reconciliation, independent qualification/publication and historical gaps separately OPEN_NOT_ZERO. No substantive serializer/control/validator/cleanup work shifted into tail.", + "wall_CPU": "Full GNUtime observer-command wall and CPU, whole observer SELF+waited-child CPU; sum each reaped process once. Source-fixed complete success tree permits complete core CPU; interrupted/unreaped failures disclose OPEN_NOT_ZERO and cannot qualify." + }, + "activity_boundary": { + "decompressions": 0, + "method": "Passive source/AST/hash/metadata plus independent ELF byte parsing only", + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_calls": 0, + "target_imports": 0, + "tests_controls_benchmarks": 0 + }, + "admission_template_sha256": "a42c3e6ade467b142647e2e3aac2ce53e67de1ba2309fcc15ec9a8d98c440f88", + "checks": { + "actual_runtime": "95 current runtime/native source metadata identities read back exact; independently parsed17 ELF PT_INTERP/DT_NEEDED metadata matches authored closure; actual dynamic module/map/provider/builtin success remains first admitted fixed operation predicate. No fictitious zlib extension.", + "cleanup": "Success complete output/private-stage cleanup independently validated inside core; all actual substantive receipt/source/runtime/log/custody checks before core endpoint; first failures/partial source/output evidence retained.", + "controls": "Six concrete observer controls;39 loader and unchanged70+new15 consumer cases for each normal/-O mode. First failure stops complete one180s command; no retry/reroll/split/resize; genuine first optimization0 baseline/candidate and independent bounded complete validator.", + "custody": "Fresh distinct regular0444 stage copies,0555 directories, no symlink/hardlink aliases, current modes/identity and complete source/input hashes before/after; manifest/anchor retained as package provenance; no cached PASS.", + "exact_source_packet": "All19 readonly members match frozen readiness;10 Python sources AST parsed; entire37-member stage source spec matches current exact I1/I2/v2/provenance bytes.", + "originals": "Unchanged full EXPECTED/reference/candidate/70controls/modes and complete genuine evidence object; no scientific construction/cache/retention/resumedcaller.", + "runtime_binding": "No-site isolated runtime; actual origins/maps and selected JSON/hash/zlib providers checked before/after; broad effective code/default/closure/global/builtin/class-method fingerprints; source-bound paid tempfile lazy state initialization; conditional real-arm package dependencies included before seal.", + "sequence": [ + "observer-controls", + "loader-controls-normal", + "consumer-controls-normal", + "loader-controls-O", + "consumer-controls-O", + "baseline-first", + "candidate-first", + "independent-validation" + ] + }, + "complete_precise_scope": "Complete repaired concrete immutable custody/runtime/source/effective-binding/sampler/observer/control/validator coordinator and finite prospective operation bill for fixed authentic retained-value O03 replay, source only. Entire precise source lane accepted; actual parent admission and dynamic evidence remain separate.", + "created_utc": "2026-10-31T08:29:22.389043+00:00", + "decision": "ACCEPT", + "execution_admitted": false, + "invalidation": "Changed executable/source/spec/input/runtime/dependency binding invalidates dependent source admission. Administrative exact I4 fill must be independently reviewed before any target run; no source repair or dynamic retry is granted by this acceptance.", + "lane": "I3", + "original_goal_credit": 0, + "repairs": { + "R1": "All37 declared package members/245041bytes exact; whole accepted I1/I2 packets and all3 control specs now staged.", + "R2": "Source-fixed per-job loader/reference/candidate package preloads before effective seal; exact module names are reused by real consumer main. Validator preloads none of them.", + "R3": "Orphan fixture replaced by required source-fixed PID-membership-and-reaped-cleanup control; successful fixture/coordinator tree waits/reaps all descendants. No orphan/reparenting control PASS claimed.", + "used": 1, + "v1_CPU_supplement": "I3-v1-REJECTION-SUPPLEMENT.json", + "v1_complete_snapshots_retained": true, + "v1_rejection": "I3-REVIEW-v1.json" + }, + "reviewer_symbolic_bill_annotation": { + "explanation": "Authored bill117440512 counts112MiB large arrays; source short fixture also allocates1024bytes. Add this known1KiB; implicit Python/runtime allocations remain measured additional work. No source or operation behavior changed by this reviewer arithmetic annotation.", + "explicit_fixture_bytearray_payload_total_bytes": 117441536 + }, + "runtime_sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "schema": "o03-independent-I3-source-review-v2", + "source_evidence": "I3-v2-EVIDENCE.json", + "source_readiness_sha256": "c1e8bc8bff2fce24e9c9000ca53cc258d72fc0c8929bc558d02069de7e220fc2" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-EVIDENCE.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-EVIDENCE.json new file mode 100644 index 0000000000..a1dfc4fd1d --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-EVIDENCE.json @@ -0,0 +1,496 @@ +{ + "actual_runtime_not_inspected": true, + "actual_stage_missing_specs": [ + "consumer/CONTROL-SPEC.json", + "consumer/CONSUMER-CONTROL-SPEC-v1.json", + "loader/CONTROL-SPEC-v1.json" + ], + "all_source_AST_parsed": [ + "bootstrap.py", + "custody.py", + "effective.py", + "loader_controls.py", + "observer.py", + "observer_controls.py", + "observer_fixture.py", + "sequence_worker.py", + "worker.py" + ], + "readiness_sha256": "e3f4f6e68b0dd7d66b2b269a346b09cfb315154c5a833cb05ed6db74e17101a2", + "runtime_file_backed_module_paths_not_pinned": [], + "runtime_metadata_mismatches": [], + "runtime_source_metadata_readbacks": [ + { + "matches": true, + "path": "/etc/python3.12/sitecustomize.py", + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e" + }, + { + "matches": true, + "path": "/usr/bin/python3.12", + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f" + }, + { + "matches": true, + "path": "/usr/bin/time", + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10" + }, + { + "matches": true, + "path": "/usr/bin/timeout", + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52" + }, + { + "matches": true, + "path": "/usr/lib/locale/C.utf8/LC_CTYPE", + "sha256": "59015993b1b671273461ef1167d7a9ad76dc090d521c91102e962217ed6b6dba" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/__future__.py", + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/_collections_abc.py", + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/_compression.py", + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/_sitebuiltins.py", + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/_weakrefset.py", + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/abc.py", + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/argparse.py", + "sha256": "29395feb61bc376ca4ff9d44069af8d914ec2a1f25a4bd7978f6e2afef5bc07f" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/ast.py", + "sha256": "d16626aa5c054bcc45221e56f84e55051b046caf0f8be1fe4902ea71534fb735" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/bisect.py", + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/bz2.py", + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/codecs.py", + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/collections/__init__.py", + "sha256": "0af967cd58036507b3d0fbc33b7a996c61dbb52a94b0b738c8bef12cd4cc7dd4" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/collections/abc.py", + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/contextlib.py", + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/copy.py", + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/copyreg.py", + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/datetime.py", + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/encodings/__init__.py", + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/encodings/aliases.py", + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/encodings/ascii.py", + "sha256": "578aa1173f7cc60dad2895071287fe6182bd14787b3fbf47a6c7983dfe3675e3" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/encodings/latin_1.py", + "sha256": "b75503e532a27c636477396c855209ff5f3036536d2a4bede0a576c89382b60c" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/encodings/utf_8.py", + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/enum.py", + "sha256": "c8ead615c159598370295649eb296819ad4b40d50b200c4fec2d4269bf7af9ae" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/fnmatch.py", + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/functools.py", + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/genericpath.py", + "sha256": "2b0b35d2206778af4081cf81dd9b513876e72c35a55bec941402e1fa62b1f1aa" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/gettext.py", + "sha256": "1cc6fd33bdce3bb29c0c37ec9a2f5bf15a315e9776b329247e6675c028a8af39" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/gzip.py", + "sha256": "31e7275c5c20d1b414063c28088b68e7a3e657af60c9c23435bf92e77a1fd1e5" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/hashlib.py", + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/importlib/__init__.py", + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/importlib/_abc.py", + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/importlib/_bootstrap.py", + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/importlib/_bootstrap_external.py", + "sha256": "97c6211750d63067712ad2cd74d50be33337f1fb1cd2c769022ced9b401edd92" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/importlib/machinery.py", + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/importlib/util.py", + "sha256": "ca54e6458dbe521d591e5b8d9bb651ef929bfae946706c98470cdd569041a64f" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/io.py", + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/ipaddress.py", + "sha256": "cc9831e239bd81c1480a12733bded744002d93815fd0d083c77aea348c956e67" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/json/__init__.py", + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/json/decoder.py", + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/json/encoder.py", + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/json/scanner.py", + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/keyword.py", + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so", + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so", + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so", + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so", + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so", + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/locale.py", + "sha256": "d1134b7212bad37b7b81339061dc37a19a194aa183ec2cb60412cf365993b151" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/lzma.py", + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/ntpath.py", + "sha256": "c4dd79bf103677daaad873952b89fc1f973425e7b250006cc35af4c164181da8" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/operator.py", + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/os.py", + "sha256": "316d1b7307fd851bded3423c9d437e0a383c725d993f0fcff2e8b749fe560b62" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/pathlib.py", + "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/platform.py", + "sha256": "ed0defe8ff7c116710493ffd099b566d3de686ab1b431a3d5401056798e59341" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/posixpath.py", + "sha256": "c443d7b8afad1717e7060ce49b3e04423058de56cd4246ee6bcc1ac962eb5c2b" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/random.py", + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/re/__init__.py", + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/re/_casefix.py", + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/re/_compiler.py", + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/re/_constants.py", + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/re/_parser.py", + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/reprlib.py", + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/selectors.py", + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/shutil.py", + "sha256": "819e518cb7a539d09b2526138015541b34d2646afb9c2f6ae4ffd476d6a0fcf4" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/signal.py", + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/site.py", + "sha256": "619436355cbe91c3b29681ab486ee63f5f2e0a7d6274dfae747bdb94e60bca55" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/stat.py", + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/struct.py", + "sha256": "9c231f9497caf513a22dee8f790b07f969b0e45854a0bdd6dd84b492e08c2856" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/subprocess.py", + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/tempfile.py", + "sha256": "8c8033ed1426ace79e07a6608887d2a1694d817d63d61b04c3d59339f24b4269" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/threading.py", + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/types.py", + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/urllib/__init__.py", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/urllib/parse.py", + "sha256": "a67b5694763137dbac085adbf0c22821d435ec8ca22d3bd3786d2c9f4ee748d5" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/warnings.py", + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/weakref.py", + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c" + }, + { + "matches": true, + "path": "/usr/lib/python3.12/zipimport.py", + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0" + }, + { + "matches": true, + "path": "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py", + "sha256": "46849a60a7cc85189cf6b5ac62b3f135004862ce6a96540a81c95ef6fbc4dc3e" + }, + { + "matches": true, + "path": "/usr/lib/python3/dist-packages/apport_python_hook.py", + "sha256": "2aac4de740babcc6038483cccc7fa71f7f06405da9b9d102aafe8ac55f509c4b" + }, + { + "matches": true, + "path": "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py", + "sha256": "c38b82e5f241e83edbbe9bcfdcb8747f11071b32fbc8b7c950e38260a0059edb" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache", + "sha256": "52c227df9d53248238602c1ddaccd2c8ddc4cc6a61aa45d7c425af590b8806a5" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4", + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/libc.so.6", + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/libcrypto.so.3", + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1", + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5", + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/libm.so.6", + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0" + }, + { + "matches": true, + "path": "/usr/lib/x86_64-linux-gnu/libz.so.1.3", + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242" + } + ], + "schema": "o03-independent-I3-v1-evidence", + "snapshot_pins": "I3-v1-SNAPSHOT-PINS.json" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-REJECTION-SUPPLEMENT.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-REJECTION-SUPPLEMENT.json new file mode 100644 index 0000000000..1cc8dc1ea0 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-REJECTION-SUPPLEMENT.json @@ -0,0 +1,24 @@ +{ + "code_locations": [ + "observer_fixture.py main orphan branch", + "observer.py terminate and main CPU resource.getrusage SELF/CHILDREN", + "observer_controls.py tracked-orphan-cleanup" + ], + "created_utc": "2026-10-31T08:23:13.847308+00:00", + "decision": "REJECT", + "execution_admitted": false, + "id": "I3-R3", + "not_an_added_obligation": "This is explicit existing Q5 actual CPU completeness, not global O09 historical or full scientific caller cost closure.", + "preserved_review": "I3-REVIEW-v1.json", + "proof_method": "Passive process-lifetime and wait/reparenting source analysis; no target/process inspection or execution", + "required_disposition": "Provide finite complete actual CPU accounting for required orphan/PID cleanup control (declared subreaper or cgroup accounting with source/runtime providers, or equivalent accepted control architecture). Do not relabel sampled /proc last CPU as actual complete CPU. Preserve failed/pending exact source scope; no milestone credit.", + "requirement": "Q5/PROBE-SPEC aggregate actual parent/descendant CPU; account every process once", + "schema": "o03-independent-I3-v1-rejection-supplement", + "smallest_source_counterexample": "observer_fixture.py orphan branch starts timeout grandchild then sleeps0.15 and returns without child.wait. It exits, so the grandchild is reparented outside admitted ancestry. Observer known-PID tracking can kill it after survival detection but observer is not that process parent and cannot wait4/reap its CPU under current code. Observer resource.RUSAGE_CHILDREN and outer GNUtime only inherit reaped descendant usage; orphan final CPU is missing.", + "source_pins": { + "observer.py": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "observer_controls.py": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "observer_fixture.py": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0" + }, + "target_activity": 0 +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-SNAPSHOT-PINS.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-SNAPSHOT-PINS.json new file mode 100644 index 0000000000..5a584f2346 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v1-SNAPSHOT-PINS.json @@ -0,0 +1,107 @@ +{ + "created_utc": "2026-10-31T08:19:36.732022+00:00", + "files": { + "ADMISSION-TEMPLATE-v1.json": { + "actual_sha256": "30cb1f9d8ba4fb886a43793bf783f3fcdf69fa98cc658ee42eaacb26424825fe", + "bytes": 18528, + "declared_sha256": "30cb1f9d8ba4fb886a43793bf783f3fcdf69fa98cc658ee42eaacb26424825fe", + "matches": true + }, + "FIXED-SEQUENCE-v1.json": { + "actual_sha256": "e156d8b8600d45b13646f24e46e8e6a3ac05b554c2df81d464447944c0e0095c", + "bytes": 4529, + "declared_sha256": "e156d8b8600d45b13646f24e46e8e6a3ac05b554c2df81d464447944c0e0095c", + "matches": true + }, + "OPERATION-BILL-v1.json": { + "actual_sha256": "e7b0e21fdc01dc350ca5f71eb84757ae37161b527ea8eef82b14c63d9c79f97c", + "bytes": 3577, + "declared_sha256": "e7b0e21fdc01dc350ca5f71eb84757ae37161b527ea8eef82b14c63d9c79f97c", + "matches": true + }, + "PASSIVE-CHECKS-v1.json": { + "actual_sha256": "e8a7c60e568ef9ea57b9ae612145d46dbd372aae9d053eedb4c034d2864a725e", + "bytes": 1909, + "declared_sha256": "e8a7c60e568ef9ea57b9ae612145d46dbd372aae9d053eedb4c034d2864a725e", + "matches": true + }, + "README-v1.md": { + "actual_sha256": "c5337759f784b15e5a45a937ce12e767aea23ed86b1e901efc79da0cbac06d84", + "bytes": 7602, + "declared_sha256": "c5337759f784b15e5a45a937ce12e767aea23ed86b1e901efc79da0cbac06d84", + "matches": true + }, + "RUNTIME-PINS-v1.json": { + "actual_sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0", + "bytes": 27394, + "declared_sha256": "5bc740c46711816372ef64be99adb7c5aafbeb768f7a149b4fc4c90431d086f0", + "matches": true + }, + "RUNTIME-PINS-v1.sha256": { + "actual_sha256": "067af3eb524cc3ea7a8389bac3ff93e50e14159565521977d7bede26f055ef42", + "bytes": 65, + "declared_sha256": "067af3eb524cc3ea7a8389bac3ff93e50e14159565521977d7bede26f055ef42", + "matches": true + }, + "SOURCE-READINESS-v1.json": { + "actual_sha256": "e3f4f6e68b0dd7d66b2b269a346b09cfb315154c5a833cb05ed6db74e17101a2", + "bytes": 3504 + }, + "bootstrap.py": { + "actual_sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb", + "bytes": 7884, + "declared_sha256": "19e09197b2b1472a2cad314f347a77e18dbf51d7a5818eeb473704b801bb6cbb", + "matches": true + }, + "custody.py": { + "actual_sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "bytes": 4943, + "declared_sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "matches": true + }, + "effective.py": { + "actual_sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "bytes": 4274, + "declared_sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "matches": true + }, + "loader_controls.py": { + "actual_sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "bytes": 797, + "declared_sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "matches": true + }, + "observer.py": { + "actual_sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "bytes": 14564, + "declared_sha256": "c3ad257f04b15632246872988cfa1c11a67740ce5d5bfb2c79928edefc18afa4", + "matches": true + }, + "observer_controls.py": { + "actual_sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "bytes": 3694, + "declared_sha256": "95c6727d6bc8c46f98ba224343ed8df3cc1e60bd989786addfb84f9e41807f7e", + "matches": true + }, + "observer_fixture.py": { + "actual_sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0", + "bytes": 2038, + "declared_sha256": "4d2491f6868c28de3ab5dbb60d51ea7dcaa30a85e8a32b980763e502d8ef27b0", + "matches": true + }, + "sequence_worker.py": { + "actual_sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "bytes": 4772, + "declared_sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "matches": true + }, + "worker.py": { + "actual_sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1", + "bytes": 6828, + "declared_sha256": "2360f712a102afcee571c10f9804f868ac74220e4735aca4ac1be0a2bb8dc2a1", + "matches": true + } + }, + "schema": "o03-rejected-I3-v1-source-snapshot-pins", + "snapshot": "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/review/I3-v1-source-snapshot" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v2-EVIDENCE.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v2-EVIDENCE.json new file mode 100644 index 0000000000..b706256dac --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I3-v2-EVIDENCE.json @@ -0,0 +1,366 @@ +{ + "ELF_RPATH_and_actual_binding_not_claimed": true, + "ELF_independent_passive_metadata": { + "/usr/bin/env": { + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/bin/python3.12": { + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "metadata_exact": true, + "needed": [ + "libm.so.6", + "libz.so.1", + "libexpat.so.1", + "libc.so.6" + ] + }, + "/usr/bin/time": { + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/bin/timeout": { + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libbz2.so.1.0", + "libc.so.6" + ] + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libcrypto.so.3", + "libc.so.6" + ] + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "interpreter": null, + "metadata_exact": true, + "needed": [] + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "liblzma.so.5", + "libc.so.6" + ] + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "interpreter": null, + "metadata_exact": true, + "needed": [] + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "interpreter": "/lib64/ld-linux-x86-64.so.2", + "metadata_exact": true, + "needed": [ + "ld-linux-x86-64.so.2" + ] + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6", + "ld-linux-x86-64.so.2" + ] + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "interpreter": null, + "metadata_exact": true, + "needed": [ + "libc.so.6" + ] + } + }, + "activity": "Passive exact source/AST/hash/metadata and independently written ELF header byte parsing only; no target code/import/function/control/decode/process/network work", + "all_accepted_I1_I2_packet_and_control_specs_present_exact": true, + "all_source_AST_parsed": 10, + "created_utc": "2026-10-31T08:27:41.557702+00:00", + "entry_package_preloads": { + "baseline-first": [ + "frozen_h25_inputs", + "reference" + ], + "candidate-first": [ + "frozen_h25_inputs", + "reference", + "bounded_serialization" + ], + "consumer-controls-O": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "consumer-controls-normal": [ + "reference", + "bounded_serialization", + "serialization_controls", + "full_consumer" + ], + "independent-validation": [], + "loader-controls-O": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "loader-controls-normal": [ + "frozen_h25_inputs", + "frozen_input_controls" + ], + "observer-controls": [] + }, + "fixed_sequence_exact": true, + "runtime_actual_dynamic_not_inspected": true, + "runtime_count": 95, + "runtime_current_metadata_pins_exact": [ + "/etc/python3.12/sitecustomize.py", + "/usr/bin/env", + "/usr/bin/python3.12", + "/usr/bin/time", + "/usr/bin/timeout", + "/usr/lib/locale/C.utf8/LC_CTYPE", + "/usr/lib/python3.12/__future__.py", + "/usr/lib/python3.12/_collections_abc.py", + "/usr/lib/python3.12/_compression.py", + "/usr/lib/python3.12/_sitebuiltins.py", + "/usr/lib/python3.12/_weakrefset.py", + "/usr/lib/python3.12/abc.py", + "/usr/lib/python3.12/argparse.py", + "/usr/lib/python3.12/ast.py", + "/usr/lib/python3.12/bisect.py", + "/usr/lib/python3.12/bz2.py", + "/usr/lib/python3.12/codecs.py", + "/usr/lib/python3.12/collections/__init__.py", + "/usr/lib/python3.12/collections/abc.py", + "/usr/lib/python3.12/contextlib.py", + "/usr/lib/python3.12/copy.py", + "/usr/lib/python3.12/copyreg.py", + "/usr/lib/python3.12/datetime.py", + "/usr/lib/python3.12/encodings/__init__.py", + "/usr/lib/python3.12/encodings/aliases.py", + "/usr/lib/python3.12/encodings/ascii.py", + "/usr/lib/python3.12/encodings/latin_1.py", + "/usr/lib/python3.12/encodings/utf_8.py", + "/usr/lib/python3.12/enum.py", + "/usr/lib/python3.12/fnmatch.py", + "/usr/lib/python3.12/functools.py", + "/usr/lib/python3.12/genericpath.py", + "/usr/lib/python3.12/gettext.py", + "/usr/lib/python3.12/gzip.py", + "/usr/lib/python3.12/hashlib.py", + "/usr/lib/python3.12/importlib/__init__.py", + "/usr/lib/python3.12/importlib/_abc.py", + "/usr/lib/python3.12/importlib/_bootstrap.py", + "/usr/lib/python3.12/importlib/_bootstrap_external.py", + "/usr/lib/python3.12/importlib/machinery.py", + "/usr/lib/python3.12/importlib/util.py", + "/usr/lib/python3.12/io.py", + "/usr/lib/python3.12/ipaddress.py", + "/usr/lib/python3.12/json/__init__.py", + "/usr/lib/python3.12/json/decoder.py", + "/usr/lib/python3.12/json/encoder.py", + "/usr/lib/python3.12/json/scanner.py", + "/usr/lib/python3.12/keyword.py", + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so", + "/usr/lib/python3.12/locale.py", + "/usr/lib/python3.12/lzma.py", + "/usr/lib/python3.12/ntpath.py", + "/usr/lib/python3.12/operator.py", + "/usr/lib/python3.12/os.py", + "/usr/lib/python3.12/pathlib.py", + "/usr/lib/python3.12/platform.py", + "/usr/lib/python3.12/posixpath.py", + "/usr/lib/python3.12/random.py", + "/usr/lib/python3.12/re/__init__.py", + "/usr/lib/python3.12/re/_casefix.py", + "/usr/lib/python3.12/re/_compiler.py", + "/usr/lib/python3.12/re/_constants.py", + "/usr/lib/python3.12/re/_parser.py", + "/usr/lib/python3.12/reprlib.py", + "/usr/lib/python3.12/selectors.py", + "/usr/lib/python3.12/shutil.py", + "/usr/lib/python3.12/signal.py", + "/usr/lib/python3.12/site.py", + "/usr/lib/python3.12/stat.py", + "/usr/lib/python3.12/struct.py", + "/usr/lib/python3.12/subprocess.py", + "/usr/lib/python3.12/tempfile.py", + "/usr/lib/python3.12/threading.py", + "/usr/lib/python3.12/types.py", + "/usr/lib/python3.12/urllib/__init__.py", + "/usr/lib/python3.12/urllib/parse.py", + "/usr/lib/python3.12/warnings.py", + "/usr/lib/python3.12/weakref.py", + "/usr/lib/python3.12/zipimport.py", + "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py", + "/usr/lib/python3/dist-packages/apport_python_hook.py", + "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py", + "/usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache", + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2", + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4", + "/usr/lib/x86_64-linux-gnu/libc.so.6", + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3", + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1", + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5", + "/usr/lib/x86_64-linux-gnu/libm.so.6", + "/usr/lib/x86_64-linux-gnu/libz.so.1.3" + ], + "schema": "o03-independent-I3-v2-evidence", + "source_package_bytes": 245041, + "source_package_count": 37, + "source_packet_members": { + "ADMISSION-TEMPLATE-v2.json": { + "mode": 292, + "sha256": "a42c3e6ade467b142647e2e3aac2ce53e67de1ba2309fcc15ec9a8d98c440f88", + "size": 25423 + }, + "ELF-CLOSURE-v2.json": { + "mode": 292, + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "size": 8733 + }, + "FIXED-SEQUENCE-v2.json": { + "mode": 292, + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf", + "size": 5379 + }, + "OPERATION-BILL-v2.json": { + "mode": 292, + "sha256": "49f9ae04f02cf01f709cda31628a4223aebe206e0778ab0e91eee176ceed96a1", + "size": 4762 + }, + "PASSIVE-CHECKS-v2.json": { + "mode": 292, + "sha256": "b7bb642363b16034690ebbc16f6546d4e15e3cac038c4698e743d5427c52f6e0", + "size": 2440 + }, + "README-v2.md": { + "mode": 292, + "sha256": "46818370bf55026df7b05b2eb439a77d6ce5dba3d74fa97844a651a51a2a9a93", + "size": 9784 + }, + "RUNTIME-PINS-v2.json": { + "mode": 292, + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "size": 28663 + }, + "RUNTIME-PINS-v2.sha256": { + "mode": 292, + "sha256": "3bdd33b13783a402ecd4b3d48fbba117b7b72275317d3b23537ca972e4909d8e", + "size": 65 + }, + "SOURCE-REPAIR-v2.json": { + "mode": 292, + "sha256": "35bc801f6fb32857ad8e3c5ccd9eea2d0540f8aa470f0d8d8e194a1522f2f589", + "size": 854 + }, + "bootstrap.py": { + "mode": 292, + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "size": 8248 + }, + "custody.py": { + "mode": 292, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "size": 4943 + }, + "effective.py": { + "mode": 292, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "size": 4274 + }, + "loader_controls.py": { + "mode": 292, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "size": 797 + }, + "observer.py": { + "mode": 292, + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "size": 15188 + }, + "observer_controls.py": { + "mode": 292, + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "size": 3757 + }, + "observer_fixture.py": { + "mode": 292, + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "size": 2125 + }, + "parent_readback.py": { + "mode": 292, + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "size": 3894 + }, + "sequence_worker.py": { + "mode": 292, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "size": 4772 + }, + "worker.py": { + "mode": 292, + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "size": 6912 + } + }, + "source_readiness_sha256": "c1e8bc8bff2fce24e9c9000ca53cc258d72fc0c8929bc558d02069de7e220fc2", + "v1_rejection_preserved": true +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I4-EVIDENCE-v1.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I4-EVIDENCE-v1.json new file mode 100644 index 0000000000..4ba1dae6d7 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I4-EVIDENCE-v1.json @@ -0,0 +1,505 @@ +{ + "accepted_v2_source19_and_runtime95_refreshed_exact": true, + "administrative_difference_keys": [ + "canonical_ledger", + "consumed_marker", + "independent_source_accepted", + "operation_root", + "parent_boundary", + "parent_execution_admitted" + ], + "all23_admitted_fresh_ledger_metadata_pins_exact": true, + "all_four_destination_paths_fresh": true, + "chain_arithmetic_and_links_exact": true, + "command_shell_parse_matches_argv": true, + "created_utc": "2026-10-31T08:38:52.625826+00:00", + "current_policy_seconds": "94.210533479", + "files": { + "outputs/h25-data-handling-20261028/control/AGENT-TASK-INDEX-native-fields-v385.json": { + "bytes": 328583, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "06beb4ec41a750959b3a441f2eaaa3d930680b80f869d5bab643aeb3b393afb5", + "symlink": false + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/anchor.json": { + "bytes": 1926, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "bbe53360088e1d7183a9801d3954bd723f580cb283d2f8dd0bb7a54ebb80c298", + "symlink": false + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/MANIFEST.json": { + "bytes": 1912, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "297e157fd2bac8f801cba6b7491368cf7dd49bae2df59483161e084a1b5fae8c", + "symlink": false + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/complex-network.json": { + "bytes": 5662, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "1f763d95c7ff163aa71d13cd82784f16665be8afb21f75e76941e2119562098f", + "symlink": false + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/rank-trace.json.gz": { + "bytes": 22029, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "20e76cd894807cf84ca740312fdc2a73d1d70740e2f0c5ec55b3d0afdd9311fa", + "symlink": false + }, + "outputs/h25-data-handling-20261028/publication-repo/research/h25-bookkeeping/payload/baseline/evidence/canonical/witness.json.gz": { + "bytes": 16995263, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "8e1b8b03320d5e077c0414c3644396faf182bdfa1a72d8067c8fea8a33dbf5d0", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/control/ROUND-CLOSE-v1.json": { + "bytes": 1844, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "211a0e5440bbccc404b5113b64d44fe9fc985ef5817a78a4f904a94a714dd82d", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-001.json": { + "bytes": 2965, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "9f00b5b1f8760a9254a8bc93af2f92f93c763e991b0d9daa062f9b27920ed7e4", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-002.json": { + "bytes": 2920, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "525b5c3fb927d947db28ce4aa83e97a249688d68505ad30e3117a22000a7ee78", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-003.json": { + "bytes": 2920, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "d068465be6fc557983031a7a7c9b5f9e1f2670227f72eb1a23dfffe72df8c547", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-004.json": { + "bytes": 2927, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "e5795c9f6640a5ac417c14dcf25255ad39b970b27341638e62b0dcdaa08ca5a4", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-005.json": { + "bytes": 2927, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "0cd8093d3f6de2618a437adc5164416b8fb3190c039491cd184c5a30223f43b3", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/ADMISSION-006.json": { + "bytes": 2920, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "e9063e1f1f40b8a97994d3faa4591e1ed0cfa00696dccda505f15ef50026c4a2", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-001.json": { + "bytes": 2025, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "5f727491e2c54925229e74f855ad7b881b5dac8a958474300f1b226b8134ebca", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-002.json": { + "bytes": 1995, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "344cc1cb001843244a7d873c8c95f797cffd19eefd38b84ceab028d283400e9a", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-003.json": { + "bytes": 1995, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "341c6c55ebe45b3f06a7d5f7c57eede4276541f5eca109e53c6ec49707ce6e86", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-004.json": { + "bytes": 1999, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "4e9cfd0d4c29a5bfdc9fc3d0ab33c179329c0b2efa7962ba6e6f2b4b5de50ca8", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-005.json": { + "bytes": 1999, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "ca3c54527ba7a23359dca6873e2ab69245b739c2b577fb6072bf2a954f871d81", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/digest-reuse-20261031/execution-v1/control/LEDGER-006.json": { + "bytes": 1995, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "d323469d15edef8ef803ca4241dcd7164010fd77044286220d2ef0d6bf7e15fd", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/control/ROUND-CLOSE-v1.json": { + "bytes": 775, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "c859ab874ef8f46ffe417b22ed46a6d78ad6d9688bfb5d7113d2a494ff8830de", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LEDGER-001.json": { + "bytes": 2093, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "f29bae9908352221e2f6341e137ad39e22899efccaf7151eb1962e9b85447e6b", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-001.json": { + "bytes": 2954, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "18d39ae470e131249a0380bf254d140739c6ddc41e29cd0d29f511bd88312448", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-002.json": { + "bytes": 2924, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "9773784a0a02b08b4f3972fe0e954006d626700093a122ccebfc0ed5d89d3bd3", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-003.json": { + "bytes": 2923, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "79cefa10887c393c80bb78b1038155013605252f81383648920d771bdbb9c500", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-004.json": { + "bytes": 2982, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "8cf5f8b1a1e53436d02cd3be99ffd114f6582433db9b1f6ab19d8ae0ab6bc2e8", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/PLAN-v1.md": { + "bytes": 6135, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "20ea5ea9d56d37215532b7ebdc03ac8673ab59a4d51ef63fea9b201eed976234", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONSUMER-CONTROL-SPEC-v1.json": { + "bytes": 736, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "778e3ac927b04975e6384e520643905f599697a194b5f0692b6da830acfaf583", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/CONTROL-SPEC.json": { + "bytes": 3062, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/DEPENDENCIES-v1.json": { + "bytes": 3934, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "4e1662505f9222182a1c196e92dff1ad8723fe00a8bbb66da2d78d43de557c69", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PACKAGE-PINS-v1.json": { + "bytes": 2453, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "92f7c5c3144d0afe56378e02e3bd62ba6e85b6d0d2afb4b8f8cc34bb29cd55fc", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 719, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "2fdb780e5662a977866ead1618e25b2dae5ef87d4cb481229540796a0d3ef875", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/PASSIVE-CHECKS-v1.json": { + "bytes": 2637, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "f333540aeb8c3e6bc5d163af57b37900ebea03d4e0de627ac9f2ddfac6182381", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/README-v1.md": { + "bytes": 6609, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "791403b86b783677180ab20d3af97d00f732dcd1aa9e5f263b419f410b20bdf7", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/SOURCE-READINESS-v1.json": { + "bytes": 2081, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "51459c38c323ef42ddce7ab33aa8a750678a1f47be4d1d8bbc0014533dc08606", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/full_consumer.py": { + "bytes": 9411, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "36002d24df4f78af96039d4df59bd0f8d6763b16cc720ce3e9d272997d50a688", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/reference.py": { + "bytes": 2141, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/run_controls.py": { + "bytes": 6630, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "e4b92d26446170a41e6f93425e8cb65dd82ff6019fb11babc908c2967e818cbf", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/consumer/validate_outputs.py": { + "bytes": 14577, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "09608d269845ee57b58681582266a6cc0dc3c5083622c0b1c61ed3cbdcccb73e", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/control/AUTHORIZATION-v1.json": { + "bytes": 1169, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "b17cbae1130d54ccbde3fc59ce6d2b7f887e65f1164c2416e1bf9123602655d2", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/ELF-CLOSURE-v2.json": { + "bytes": 8733, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "a8b32c6f6227cc6fa25d2d20983fb3d62ca2f4b9accf148a508689a42c1fe6d6", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/FIXED-SEQUENCE-v2.json": { + "bytes": 5379, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "9102c18101b19b31751ccf144a37822e381789ed2372551aa3e042839812c5cf", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/RUNTIME-PINS-v2.json": { + "bytes": 28663, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "4c51dbf6174a8eb418722eada754bfee54418ba317db61e1e6c6d0c82da4fdea", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/bootstrap.py": { + "bytes": 8248, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "de6a98a3bb93e7c269ef123dfb184929c6cf0ca895908375567e6d40612e02a2", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/custody.py": { + "bytes": 4943, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "d738301d2fa281ef910f7acc2c864a0752c82879e77b29d55d96f62c6b8b2b87", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/effective.py": { + "bytes": 4274, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "a1bced3b61d11b1aa6d7bf3a68bd97f8878cebe84e53c8cec4339fb59ef56830", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/loader_controls.py": { + "bytes": 797, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "ddc4d711c3b0b162af4d0855364e83f33423cfc7fa524a368f720eaa460d802f", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer.py": { + "bytes": 15188, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "49bedc6a2937a579231eff9b1f750c6f81065812281201850e98b65f928644b6", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_controls.py": { + "bytes": 3757, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "ee944d50d624f2244ae06b82c2f6c2e677c95e6d68395635e72460d17d7605dd", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/observer_fixture.py": { + "bytes": 2125, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "0324abfbf19c5a3585479508fccc4031cc340f8757a8e4675658363b3f794788", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/parent_readback.py": { + "bytes": 3894, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "332ab22e4b2838fc71abc8a39d971507c1b3a8dfecee2c202eff6d3fa172a6bf", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/sequence_worker.py": { + "bytes": 4772, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "8971bac232900c4d9c28c8139cc36f6c41e7ac0df0df7faf3405fb040c8d1557", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/envelope/revision-v2/envelope/worker.py": { + "bytes": 6912, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "a27d9ce46c2ac1adfdf7ce894922a9261404e4ef4b36fe0d5079a78c421c8487", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/COMMAND-v1.json": { + "bytes": 2540, + "mode_octal": "0o444", + "sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/I4-PACKET-v1.json": { + "bytes": 1335, + "mode_octal": "0o444", + "sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/LEDGER-RECONCILIATION-v1.json": { + "bytes": 4139, + "mode_octal": "0o444", + "nlink": 1, + "sha256": "91f07df47d4613ca062328d671a160443260645d2105cf922db6d190d8c56933", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/READBACK-COMMAND-v1.json": { + "bytes": 2909, + "mode_octal": "0o444", + "sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/execution-v1/control/complete-fixed-o03-admission.json": { + "bytes": 33047, + "mode_octal": "0o444", + "sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1" + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/API-v1.md": { + "bytes": 5012, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "c8b3f95ebca10c93c46df925deefa1e72c3a257ce2f4bacae15fc5b3ff261677", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/CONTROL-SPEC-v1.json": { + "bytes": 2002, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "8d30db86b74e4306db8e1079a224bf75a12c04ba49551852e95abab01f9bae3c", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PACKAGE-PINS-v1.json": { + "bytes": 1152, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "6fb704edc1f76f99e7a9d9c52498a35b8b26d6b50d5a00952d1d37f84eb0ae71", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/PASSIVE-ATTEMPTS-v1.json": { + "bytes": 586, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "fe95314ab97a70ff9ab90fc092155b6dbd9c359d758631c6f608474dc273c7a4", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-PINS-v1.json": { + "bytes": 2395, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "863ff12c625616c8bb732e283fa5eb25c677a5a24957928a0f6d5ada788ed93e", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/SOURCE-READINESS-v1.json": { + "bytes": 2306, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "37e2542ebed6d95016b215f3547333b64a682ce3fcd19db89edbd00750fe4c6f", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_h25_inputs.py": { + "bytes": 14650, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "fa8815a8c0d408d5a07944ee1407a00cd73c05ebb2de8965553fe6edaca8e57a", + "symlink": false + }, + "outputs/h25-data-handling-20261028/streams/serializer-o03-implementation-20261031/loader/frozen_input_controls.py": { + "bytes": 13181, + "mode_octal": "0o664", + "nlink": 1, + "sha256": "002b128e3627919e29fe3da42ebe6345a7854f898774b6ce106ae0a0f973e10c", + "symlink": false + }, + "outputs/h25-stable-packages-publication-20261031/control/VALIDATION-LEDGER-006.json": { + "bytes": 3988, + "mode_octal": "0o664", + "sha256": "df16cd790ef27f3008399d73ea2ad068d2fab7e844a713fd96244430ed3e7b2a" + } + }, + "index_O03_runtime_operations": 0, + "index_active_exec_session": null, + "initial_cap_seconds": 600, + "latest_named_index_version": 385, + "lock_metadata_only": "Existing canonical regular science.lock,nlink1; no lock acquired or process state inspected by reviewer. Actual nonblocking lock is mandatory inside admitted observer.", + "packet_five_refs_exact": true, + "prior_anchor_policy_seconds": "63.770533479", + "readback_shell_parse_matches_argv": true, + "reserved_seconds": "180", + "schema": "o03-independent-I4-evidence-v1", + "source_runtime_sequence_and_pins_unchanged": true, + "target_work": 0, + "terminal_directories_counts": [ + 6, + 4, + 1 + ], + "terminal_ledger_count": 11, + "total_cap_seconds": 2400, + "upper_after_operation": "274.210533479" +} diff --git a/research/h25-authentic-serializer-20261031/validation/source-reviews/I4-REVIEW-v1.json b/research/h25-authentic-serializer-20261031/validation/source-reviews/I4-REVIEW-v1.json new file mode 100644 index 0000000000..5e9b7751e2 --- /dev/null +++ b/research/h25-authentic-serializer-20261031/validation/source-reviews/I4-REVIEW-v1.json @@ -0,0 +1,49 @@ +{ + "accepted_checkpoint": "I4", + "activity_boundary": { + "controls_tests_benchmarks": 0, + "decompressions": 0, + "method": "Passive exact source/text/hash/metadata/ledger arithmetic only", + "network_PR": 0, + "payload_decodes": 0, + "process_inspection": 0, + "protected_runs_access": 0, + "target_calls": 0, + "target_imports": 0 + }, + "admitted_count": 1, + "admitted_scope": "The exact once-only complete-fixed-o03 command and one declared finite parent readback. Fixed reviewed observer controls, loader39 and original70+consumer15 normal/-O, first optimization0 complete authentic baseline and candidate, independent complete output validator. No command/source change, retries, rerolls, adaptive split, resizing or additional target work admitted.", + "checks": { + "administrative_fill": "Only accepted template administrative keys differ; all placeholders replaced. Actual output/consumed/time/readback destinations absent and parents exist; no prior PASS used. All source/runtime/sequence/input pins unchanged.", + "billing_annotation": "Parent explicitly binds117441536bytes fixed fixture payload including reviewer-known1KiB short fixture.", + "closing_readback": "Exact accepted parent_readback.py with same admission SHA and exact fresh paths; one finite metadata readback/report. It enforces status/CPU success-tree/samples and1GiB individual+sampled caps, full outer180s/aggregate2400 caps, conservative full outerwall+0.01charge; parent must reconcile any outcome into canonical ledger before another operation.", + "exact_launch": "env-i fixed PATH/LC_ALL/TZ, pinned timeout179s+1s kill, GNUtime exact format/fresh file, pinned Python3.12-B-I-S and accepted v2observer/admission SHA. Command text and argv independently identical.", + "finite_boundary": "Observer+waited descendant core includes actual auth/import/staging/controls/load/serialization/validation/cleanup/substantive readbacks. Initial unsampled startup and10ms/PID/shortpeak/sharedRSS limits explicit; individual maxRSS not group peak. Native controller instrumentation prefix/CPU/RSS plus final record/readback/report/ledger/review/publication remain OPEN_NOT_ZERO. No all-guard-measured claim.", + "ledger": "Exact11 terminal ledger chain and reference hashes/arithmetic verified, with authenticated63.770533479 anchor; digest6admissions and round closes bound; latest named native indexv385 records0 new O03operations and no active exec session;23 fresh metadata pins exact. Current policy94.210533479 plus180 reservation274.210533479 fits both initial600 and existing2400; no new budget. Historical physical gaps not recomputed/closed.", + "serialization": "Actual existing canonical science.lock path retained; source takes exclusive nonblocking lock and verifies fresh ledger bindings before any target. No reviewer process/lock probe performed; parent assertion all other guarded work paused is bound in reconciliation.", + "source_runtime": "All accepted19v2source packet members and95runtime/provider metadata pins re-read exact;37 source stage members and3 authentic raw transports exact; accepted I1/I2 literals/modes/controls/EXPECTED unchanged." + }, + "created_utc": "2026-10-31T08:38:52.626563+00:00", + "credit": { + "I4": true, + "I5": false, + "I6": false, + "I7": false, + "O03": false, + "caller_or_whole_goal": false, + "original_goal_credit_added": 0 + }, + "decision": "ACCEPT", + "dynamic_predicates": "Actual runtime origins/maps/providers/effective bindings, immutable copied identities, full payload schema, original/new/observer control outcomes, genuine candidate fast path, exact complete outputs/receipts/cleanup, resource fit and cost-evidence qualification are unexecuted predicates. Their first failure stops this single admitted operation and preserves evidence.", + "evidence": "I4-EVIDENCE-v1.json", + "exact_admission_sha256": "fc4f08e14ae6553e9b7445dd2efcb5b83d41262d7f8c9ec3b3d29d4068591fe1", + "exact_command_sha256": "c74335531fad634bfd58358e999b2653b8adabcbd17a5affad67986c7d476dbb", + "exact_packet_sha256": "4dfc96f5e6a36631b9892efa706088ee2a270aaba9a8f54701d6cdcbb444a879", + "exact_readback_command_sha256": "a1e1bd79f0713d1ddaad84ed828d676c1cb4f6eec69145cba45c1c954a1780f5", + "execution_admitted": true, + "hard_round_deadline_utc": "2026-10-31T09:04:36.048558+00:00", + "invalidation": "Any exact admitted source/input/runtime/pin/command/admission/ledger-binding drift voids this once-only admission; stop rather than edit/retry. Source repair count already1 and no further repair granted.", + "owner": "Parent alone", + "postoperation_rule": "Exact immutable actual evidence requires independent review. Core PASS/readback PASS never automatically qualifies O03; I7 must decide memory/cost/gain-or-no-gain scope, disclose absent per-arm RSS series and finite outside costs. Any interrupted/unreaped failure has CPU OPEN_NOT_ZERO and cannot qualify.", + "schema": "o03-independent-exact-I4-admission-review-v1" +}