diff --git a/research/h25-bounded-serializer/PACKAGE-CHECKSUMS.json b/research/h25-bounded-serializer/PACKAGE-CHECKSUMS.json new file mode 100644 index 0000000000..1031705e79 --- /dev/null +++ b/research/h25-bounded-serializer/PACKAGE-CHECKSUMS.json @@ -0,0 +1,516 @@ +{ + "excludes": "PACKAGE-CHECKSUMS.json to avoid self-reference", + "files": [ + { + "bytes": 900, + "path": "PUBLICATION-SCOPE.json", + "sha256": "0b7937afdc9660ef645aa708330a7a0a07cf36988c95ba369d93359deb15e0f0" + }, + { + "bytes": 5308, + "path": "README.md", + "sha256": "3187ee5834f9b51bc459f8f22ed003f28034be265e71842af15f9a573719b17a" + }, + { + "bytes": 5749, + "path": "component/BILL.json", + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + { + "bytes": 3062, + "path": "component/CONTROL-SPEC.json", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + { + "bytes": 3071, + "path": "component/FEASIBILITY.json", + "sha256": "f9ff50549bae4071fb7531fe6ad2e53d2b593b8508d42dce6194ea7c3e012a61" + }, + { + "bytes": 3032, + "path": "component/ORIGINAL-SOURCE-PINS.json", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + { + "bytes": 5158, + "path": "component/README.md", + "sha256": "c74cc98f237a4ed97c77ec77555322b496c5e8a5f7544864dc55b584cc19a104" + }, + { + "bytes": 2031, + "path": "component/REFERENCE-EXTRACTION.json", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + { + "bytes": 3914, + "path": "component/SOURCE-PINS.json", + "sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" + }, + { + "bytes": 23560, + "path": "component/bounded_serialization.py", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + { + "bytes": 6761, + "path": "component/component_consumer.py", + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + { + "bytes": 6025, + "path": "component/docs/API-v2.md", + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + { + "bytes": 2421, + "path": "component/docs/API-v3.md", + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + { + "bytes": 2962, + "path": "component/docs/CONTRACT-v2.json", + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + { + "bytes": 11322, + "path": "component/docs/COST-CONTROLS.json", + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + { + "bytes": 773, + "path": "component/docs/SOURCE-READINESS-v3.json", + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + { + "bytes": 7466, + "path": "component/provenance/PROPOSAL.json", + "sha256": "9bf3f21b0b2c3db755495e5b6c4ba1b6a76e18f43f8fc1563ae31a808a1ea0ee" + }, + { + "bytes": 7162, + "path": "component/provenance/REVIEW-v3.json", + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + { + "bytes": 5465, + "path": "component/provenance/SOURCE-DESIGN.md", + "sha256": "0a12cb7945e4bb772154346c61a202b9f44e7297800306ef9ce113373af77578" + }, + { + "bytes": 10571, + "path": "component/provenance/compare_side_verifier.py", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + { + "bytes": 20334, + "path": "component/provenance/native_backend.py", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + { + "bytes": 8959, + "path": "component/provenance/profile_side_verifier.py", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + { + "bytes": 2141, + "path": "component/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + { + "bytes": 23684, + "path": "component/serialization_controls.py", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + }, + { + "bytes": 8241, + "path": "reviews/ACCEPTANCE-CHECKLIST-v1.md", + "sha256": "1e1c5061fc92325b0fc09b7a0f2f3c0b2e9e9e6b6eaafa6630fb172e608dbf37" + }, + { + "bytes": 4161, + "path": "reviews/F1-REVIEW-v1.json", + "sha256": "5af6f4c4e17be4c64d4897a9a6cef63d7bfe95d8846419d9ee66fbc8e3d2750a" + }, + { + "bytes": 4666, + "path": "reviews/F2-REVIEW-v1.json", + "sha256": "6a26b3a29132cb2ef1af67d270c5d7aa2a021ac53583f0129e1fcdce9ea61361" + }, + { + "bytes": 4439, + "path": "reviews/F4-REVIEW-v1.json", + "sha256": "856e5f2b7af1fd28fe047657c3f2fd994cc59ab3c5a1549e82f55ab706c8eb3d" + }, + { + "bytes": 4124, + "path": "reviews/FROZEN-PACKAGE-CHECK-v1.json", + "sha256": "3f1271d0a14eac1e65c835f96b9c939ae4eb02cdd404239e19d48d50ce630ff2" + }, + { + "bytes": 3279, + "path": "reviews/PARENT-ROUTE-ASSESSMENT-v1.json", + "sha256": "e93782a30ad5f4aaa98e1ea0dff225082b415a26554ed7ac644a0593a02f92ca" + }, + { + "bytes": 2168, + "path": "reviews/PRELIMINARY-SOURCE-CHECK-v1.json", + "sha256": "7ff6296d0b7801028a35581bb3ec946f0d52a4edcffd9202a5919f4c96e21f65" + }, + { + "bytes": 2477, + "path": "reviews/REVIEW-FREEZE-v1.json", + "sha256": "71ceb35c4b2d8956742cdeaa5f98c00d7eba0c0d164a0d4ed5867c8462e79f47" + }, + { + "bytes": 7993, + "path": "reviews/SOURCE-CLOSURE-v1.json", + "sha256": "b066021ebdd16e4e146deb0af732c1257e87c96b41a56da75a87ac2204848033" + }, + { + "bytes": 1948, + "path": "validation/README.md", + "sha256": "51171e2ed274eb1fecec2040a215be9dca442d5c93716691ff7b0340d9b2ccf3" + }, + { + "bytes": 20649, + "path": "validation/RUNTIME-PINS-v3.json", + "sha256": "972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02" + }, + { + "bytes": 2665, + "path": "validation/execution-source-v1/INVENTORY-PROPOSED.json", + "sha256": "963f076fe7167df374cf689c7cf8b0ed4b11031c3eb7f2f3f23c9b9313b4785b" + }, + { + "bytes": 497, + "path": "validation/execution-source-v1/JOBS.json", + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + { + "bytes": 3823, + "path": "validation/execution-source-v1/README.md", + "sha256": "b08ce8ec929e8dc8289b71fd80351476e74305bf82ffbdae9e51f4e1ea18445e" + }, + { + "bytes": 20275, + "path": "validation/execution-source-v1/RUNTIME-PINS.json", + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c" + }, + { + "bytes": 65, + "path": "validation/execution-source-v1/RUNTIME-PINS.sha256", + "sha256": "3f19eff68ec00a26632c5049950387ca94d5124dd11807f7fa0c81ee91abfc71" + }, + { + "bytes": 1104, + "path": "validation/execution-source-v1/SOURCE-PINS.json", + "sha256": "014d5289caf48fa1f4bd8b63ad3ca98ddeb0205293c4955e7622840f1da8a672" + }, + { + "bytes": 8418, + "path": "validation/execution-source-v1/integration/full_driver.py", + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + }, + { + "bytes": 2868, + "path": "validation/execution-source-v2/INVENTORY-PROPOSED.json", + "sha256": "79dd74bfeec00f8ff0b2071214fe365748dedd46bac2e7f221e925802374c178" + }, + { + "bytes": 497, + "path": "validation/execution-source-v2/JOBS.json", + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + { + "bytes": 4484, + "path": "validation/execution-source-v2/README.md", + "sha256": "150f3a390d197a7ab51d4b808b22fcb846f758487e306da6a8a086ec5b0e8b3d" + }, + { + "bytes": 20649, + "path": "validation/execution-source-v2/RUNTIME-PINS.json", + "sha256": "972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02" + }, + { + "bytes": 65, + "path": "validation/execution-source-v2/RUNTIME-PINS.sha256", + "sha256": "c6cacd389499df0b6834d2f4605c839877b112bdf0850a8a5e3776d5051c070f" + }, + { + "bytes": 3297, + "path": "validation/execution-source-v2/SOURCE-AUDIT.json", + "sha256": "f98293ad9d29eea90e4b96cb2f9f9d3b876ddc266d5f29ebbcaa63b88af747d8" + }, + { + "bytes": 1271, + "path": "validation/execution-source-v2/SOURCE-PINS.json", + "sha256": "22b114fae2de5331e1c86bad5a2b61655184bdf06eb138a1c4e2fe0d7d46bf9b" + }, + { + "bytes": 8418, + "path": "validation/execution-source-v2/integration/full_driver.py", + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + }, + { + "bytes": 4020, + "path": "validation/execution-v1-STAGE.json", + "sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c" + }, + { + "bytes": 0, + "path": "validation/execution-v1-attempts/serializer-controls-normal.stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 2000, + "path": "validation/execution-v1-attempts/serializer-controls-normal.stdout.txt", + "sha256": "311479a1728321350c3384eb7eacbe6bcbc59a7bc2ad683e0b8749651d6e5f55" + }, + { + "bytes": 119, + "path": "validation/execution-v1-attempts/serializer-controls-normal.time.txt", + "sha256": "d5d32f91891738afa592aefbe405c68ba8dcec1fffad66d5cc25d1063e5962b9" + }, + { + "bytes": 2829, + "path": "validation/execution-v1-control/ADMISSION-001.json", + "sha256": "48dd0f78b67e1bfbe7b2ca451c679a90ad595f528d7a10fe00258da0c81249d9" + }, + { + "bytes": 1365, + "path": "validation/execution-v1-control/COMMAND-001.json", + "sha256": "2afc993288e031e6d72e68c900daffc55514b0258e6bfa4d6339bc486d5f0849" + }, + { + "bytes": 289, + "path": "validation/execution-v1-control/EXECUTION-PHASE.json", + "sha256": "529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32" + }, + { + "bytes": 783, + "path": "validation/execution-v1-control/LAUNCHER-PINS-v1.json", + "sha256": "51a09ea4c1fa9b46c3767b65ca93663584b6cb5ad8266a891da6a8ff98ead4da" + }, + { + "bytes": 2093, + "path": "validation/execution-v1-control/LEDGER-001.json", + "sha256": "f29bae9908352221e2f6341e137ad39e22899efccaf7151eb1962e9b85447e6b" + }, + { + "bytes": 9908, + "path": "validation/execution-v1-control/OPERATION-PROPOSAL-v1.json", + "sha256": "a332a9e94833321960a2ad7aa79cafe0d16e6b26f1028ce6478dd47a7c24edb5" + }, + { + "bytes": 10387, + "path": "validation/execution-v1-control/OPERATION-PROPOSAL-v2.json", + "sha256": "788cd8fbb6c0c9efc5402990fc6c58d17bf761d6d337c450d15a4f6cdc96e8ac" + }, + { + "bytes": 7322, + "path": "validation/execution-v1-serializer-controls-normal-raw.json", + "sha256": "8717cb6bcc2c610bbe0152b4e174bec18233c4b52c5df8603f6715e8b6f128f3" + }, + { + "bytes": 4020, + "path": "validation/execution-v2-STAGE.json", + "sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04" + }, + { + "bytes": 0, + "path": "validation/execution-v2-attempts/serializer-baseline-2048.stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 1957, + "path": "validation/execution-v2-attempts/serializer-baseline-2048.stdout.txt", + "sha256": "a0d8120444e2dc270e2622038cb71beff1214b7ee20660841001d4938282b78c" + }, + { + "bytes": 81, + "path": "validation/execution-v2-attempts/serializer-baseline-2048.time.txt", + "sha256": "3f82a34b5950eaf2fb6af42a72503e23925efb30eadece7cf8b948c44ae905a5" + }, + { + "bytes": 0, + "path": "validation/execution-v2-attempts/serializer-candidate-2048.stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 1948, + "path": "validation/execution-v2-attempts/serializer-candidate-2048.stdout.txt", + "sha256": "c439ac597227430e26d9c29dd13a14e748c4a04058b0f679fb0e63aae778aacc" + }, + { + "bytes": 81, + "path": "validation/execution-v2-attempts/serializer-candidate-2048.time.txt", + "sha256": "9b4271ac7ac4f1a46d823f925c8ae67f8bbd3782edee9d6c0ff428c5bcf90f63" + }, + { + "bytes": 0, + "path": "validation/execution-v2-attempts/serializer-controls-O.stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 1935, + "path": "validation/execution-v2-attempts/serializer-controls-O.stdout.txt", + "sha256": "d32aa27730c83bdbdb5839755a6ecbca83269d50b822b402b8fd55593380c46f" + }, + { + "bytes": 81, + "path": "validation/execution-v2-attempts/serializer-controls-O.time.txt", + "sha256": "af15e1b7b504c15e84ff4c7819a50cbc9e510d895f53a2e39959223eaf5fb1a8" + }, + { + "bytes": 0, + "path": "validation/execution-v2-attempts/serializer-controls-normal.stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 1928, + "path": "validation/execution-v2-attempts/serializer-controls-normal.stdout.txt", + "sha256": "1e3bcf2759f90a60f918e31c0125fe512bfc06e73fbca57ec18ab190d493ef8a" + }, + { + "bytes": 81, + "path": "validation/execution-v2-attempts/serializer-controls-normal.time.txt", + "sha256": "d17b84ec4df4da64eefc34f2ef9a6685b4afd3ff301fa0c8720a83d9526a10f9" + }, + { + "bytes": 3253, + "path": "validation/execution-v2-control/ADMISSION-001.json", + "sha256": "3af9b568c1833513e946d67d35d1a9d685f52b488a1dabb4535f720481f4e961" + }, + { + "bytes": 3233, + "path": "validation/execution-v2-control/ADMISSION-002.json", + "sha256": "affa84bbca54908f0515035135093a8f302605ecf4c22dcc9e2cfc6517d91e6a" + }, + { + "bytes": 3254, + "path": "validation/execution-v2-control/ADMISSION-003.json", + "sha256": "9fa763c40db869dcfb14e901457884149622345ae8c58a289764d354a29e0344" + }, + { + "bytes": 3261, + "path": "validation/execution-v2-control/ADMISSION-004.json", + "sha256": "8c93cf1b6ce48cc3d9bbfefee1323e0d180080c1b0157e228351a5eb235d21bc" + }, + { + "bytes": 287, + "path": "validation/execution-v2-control/EXECUTION-PHASE.json", + "sha256": "b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a" + }, + { + "bytes": 783, + "path": "validation/execution-v2-control/LAUNCHER-PINS-v1.json", + "sha256": "51a09ea4c1fa9b46c3767b65ca93663584b6cb5ad8266a891da6a8ff98ead4da" + }, + { + "bytes": 2954, + "path": "validation/execution-v2-control/LEDGER-001.json", + "sha256": "18d39ae470e131249a0380bf254d140739c6ddc41e29cd0d29f511bd88312448" + }, + { + "bytes": 2924, + "path": "validation/execution-v2-control/LEDGER-002.json", + "sha256": "9773784a0a02b08b4f3972fe0e954006d626700093a122ccebfc0ed5d89d3bd3" + }, + { + "bytes": 2923, + "path": "validation/execution-v2-control/LEDGER-003.json", + "sha256": "79cefa10887c393c80bb78b1038155013605252f81383648920d771bdbb9c500" + }, + { + "bytes": 2982, + "path": "validation/execution-v2-control/LEDGER-004.json", + "sha256": "8cf5f8b1a1e53436d02cd3be99ffd114f6582433db9b1f6ab19d8ae0ab6bc2e8" + }, + { + "bytes": 11225, + "path": "validation/execution-v2-control/OPERATION-PROPOSAL-v1.json", + "sha256": "2a707d3946343121a07150157c120f210afe84329bbe6a6c7b9d61d0719f71ea" + }, + { + "bytes": 29322, + "path": "validation/execution-v2-serializer-baseline-2048-raw.json", + "sha256": "7f0bc7a44f7129473fd03256e88f9ba0a270ab8a994a12a843469096c58fd7c2" + }, + { + "bytes": 31631, + "path": "validation/execution-v2-serializer-candidate-2048-raw.json", + "sha256": "941cb4e3833819a534d3ccdd5569dc0ea9831490609f912366ec9336ba8249a7" + }, + { + "bytes": 315762, + "path": "validation/execution-v2-serializer-controls-O-raw.json", + "sha256": "853e4c2712f033aa912b7a1ec0f89d5b6d9205dd491dd23d2d22ec06d8382114" + }, + { + "bytes": 316145, + "path": "validation/execution-v2-serializer-controls-normal-raw.json", + "sha256": "9ee5c0e1cd0e15370d2b989c2f9d01aef8d8a1fcf3caeb7bd786b00dfae496fa" + }, + { + "bytes": 3991, + "path": "validation/reviews/EXACT-OPERATION-REVIEW-v1.json", + "sha256": "f12543f6fa82580a702b119a9866c6b580f046035fa55a0deaeb5c6b9ba7aea2" + }, + { + "bytes": 5733, + "path": "validation/reviews/EXACT-OPERATION-REVIEW-v2.json", + "sha256": "8ecd22a37b18a569f462f0250938023b92975a030280e8efa75f5b3b20bc09c4" + }, + { + "bytes": 1278, + "path": "validation/reviews/EXECUTION-REVIEW-FREEZE-v1.json", + "sha256": "efcb177a2221a47a24fa255ab55434cf8686810325065c829ae0ae13aa2e2f99" + }, + { + "bytes": 4523, + "path": "validation/reviews/EXECUTION-SOURCE-REVIEW-v1.json", + "sha256": "714a014a1d561a2eabc5fa68528bbe406c1c738d03d01d0fb71682568633b8e7" + }, + { + "bytes": 5792, + "path": "validation/reviews/FIRST-ATTEMPT-FAILURE-REVIEW-v1.json", + "sha256": "813cc88472149005824bf389737ac47c183bdcc668ffece5697bfa42abb1f44a" + }, + { + "bytes": 2343, + "path": "validation/reviews/PUBLIC-OUTCOME-v1.md", + "sha256": "c46be8f94d046a4fd4e64b983b3a1d890be20d83a53329398f962922f08c67d8" + }, + { + "bytes": 2402, + "path": "validation/reviews/PUBLIC-OUTCOME-v2.md", + "sha256": "57f92d6f42c714b4515c0044b3a1f2320537409857d5386e84186a27c01a2118" + }, + { + "bytes": 23130, + "path": "validation/reviews/RUNTIME-OUTCOME-REVIEW-v1.json", + "sha256": "d81065b5ba67f191b4f48705df393e12857919351eb6aa6857368777353428e6" + }, + { + "bytes": 792, + "path": "validation/reviews/RUNTIME-REVIEW-FREEZE-v1.json", + "sha256": "f9bba30d93cdfbcc61ee63033e901a324634a9e2466b8962c934459249b45e61" + }, + { + "bytes": 719, + "path": "validation/reviews/RUNTIME-REVIEW-FREEZE-v2.json", + "sha256": "753c81fbd53582282f5651ef536bd9a505aa871491fefec2fee6021045d7fe2a" + }, + { + "bytes": 3581, + "path": "validation/reviews/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json", + "sha256": "6c4ff0861968330694ba1fcb2e9d67feb2d728ba77d17d67affe14f936d65b46" + }, + { + "bytes": 12110, + "path": "validation/run_guarded.py", + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + } + ], + "schema": "h25-publication-checksums-v2" +} diff --git a/research/h25-bounded-serializer/PUBLICATION-SCOPE.json b/research/h25-bounded-serializer/PUBLICATION-SCOPE.json new file mode 100644 index 0000000000..d5f9f17268 --- /dev/null +++ b/research/h25-bounded-serializer/PUBLICATION-SCOPE.json @@ -0,0 +1,22 @@ +{ + "base_commit": "a7638a4ce2a29947457ae8d6bf8cd70a234dfeac", + "complete_physical_cost_closure": false, + "external_component_manifest_sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e", + "final_metadata_publication_boundary": "OPEN_NOT_ZERO", + "finite_artifact_bytes": 9417, + "frozen_stage_file_mode": "0444", + "full_caller_validated": false, + "local_reference_mapping": { + "review/": "reviews/", + "serializer/": "component/" + }, + "normal_controls_accepted": 70, + "optimized_controls_accepted": 70, + "pending": "Complete physical cost closure, genuine complete H25 caller and representative performance validation.", + "performance_gain_measured": false, + "public_git_mode": "100644", + "runtime_executed": true, + "schema": "h25-serializer-finite-publication-v2", + "source_accepted": true, + "source_commit": "5781edb23484619c63fdd4271abaeb72d1b432f4" +} diff --git a/research/h25-bounded-serializer/README.md b/research/h25-bounded-serializer/README.md new file mode 100644 index 0000000000..f8e23e69ca --- /dev/null +++ b/research/h25-bounded-serializer/README.md @@ -0,0 +1,31 @@ +# Bounded H25 serializer: source and retained finite validation + +This package extracts the reviewed bounded serializer and its unchanged 70-case control suite into a standalone finite consumer. The candidate stages exact canonical JSON in bounded chunks, verifies complete hashes and sizes, and publishes final artifacts only after its checks. It retains the original eager writer as a separate reference. + +The first incremental commit preserved the component and independent source reviews. This second commit adds the first admitted finite results and the earlier pre-import custody failure. Independent review accepts all 70 normal controls and all 70 optimized controls, plus exact equality of the three finite artifacts. The small baseline/candidate pair shows no demonstrated saving. Complete physical cost closure, full H25 caller validation and representative performance remain open. Authorship and review were AI-assisted with GPT-6.1-sol high agents; independent human review is not claimed. + +## Contents and source integrity + +`component/` is the exact frozen 22-file source package, including its external-pinned SOURCE-PINS.json. `reviews/` preserves the independent reviews verbatim. Their local paths, previous proposal labels and original status strings are historical provenance; this README supplies current publication scope. The component manifest SHA256 is `5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e`. The candidate, controls and five extracted reference blocks preserve exact predecessor bytes. Scientific/native modules in component/provenance are reference material and are never imported by this finite consumer. + +Git stores these as ordinary 100644 source files. Frozen local verification stages restore the declared 0444 file/0555 directory modes before custody checks; Git's mode representation is not a claim that a normal checkout is an immutable stage. PACKAGE-CHECKSUMS.json pins all other files in this publication commit, including the preserved component manifest and reviews. + +## Validation and incremental commits + +Source commit `5781edb23484619c63fdd4271abaeb72d1b432f4` remains intact in history. The second additive commit preserves complete raw finite-run bundles and independent review in `validation/`, including the first failure and charged cost. Read [the independent outcome](validation/reviews/PUBLIC-OUTCOME-v2.md) and [evidence format/replay boundaries](validation/README.md). + +Normal and optimized modes each passed the exact 70 ordered cases. Separate baseline and candidate consumers with 2048 support rows produced identical 22-byte result, 9366-byte witness and 29-byte ordered rank trace. Baseline outer wall/CPU/peak RSS were 0.26 s / 0.24 s / 20168 KiB; candidate observations were 0.27 s / 0.25 s / 22012 KiB. These single rounded observations do not support a repeatable regression magnitude or a performance gain. This finite fixture is not the complete H25 workload. + +The retained first failure occurred before target import because the runtime inventory omitted the resolved system sitecustomize origin. One source repair was independently accepted and a distinct immutable stage admitted. The four corrected operations each ran once; no test or timing was rerolled. All failures remain charged. Existing policy usage reached 75.750533479 / 2400 seconds. Complete physical preparation, independent readback and final metadata/publication costs remain unmeasured and OPEN_NOT_ZERO. + +There is no executable CI replay hook. Hosted planning checks do not establish local control or performance success. Original complete caller, typed/stdout/certificate/ordered-rank/complement equality and full wall/CPU/peak-memory qualification remain open. + +## Open next questions + +1. How does the bounded writer behave on the genuine complete H25 caller and witness? Start with a source-pinned representative route and complete validation/resource bill; this finite fixture cannot answer it. +2. Can final publication semantics be preserved with less duplicate IO? The current candidate pays staging plus final copying and hashing. Any change needs its own failure/cleanup review. +3. How should complete preparation, independent readback and final metadata-publication costs be measured? Their unmeasured boundary keeps F7 partial; nominal administrative charges are not physical measurements. + +## Provenance, credit and license + +Preserves the H25 verification/bookkeeping lineage and original source attribution, including [PR6029](https://github.com/CrocSwap/integer-mult-bounds/pull/6029), the earlier verification work [PR5864](https://github.com/CrocSwap/integer-mult-bounds/pull/5864), and the retained source-bound/reference conventions of CrocSwap/integer-mult-bounds and its contributors. The published bounded-log component [PR6316](https://github.com/CrocSwap/integer-mult-bounds/pull/6316) supplies the separate guard precedent. The three remaining cache candidates remain independently handed off in [PR6321](https://github.com/CrocSwap/integer-mult-bounds/pull/6321); this component does not close them. Prepared for Clear1nsight with substantial OpenAI Codex assistance, using GPT-6.1-sol high author/reviewer agents. Apache-2.0 under the repository license. No mathematical construction, selected-frontier or kappa change. diff --git a/research/h25-bounded-serializer/component/BILL.json b/research/h25-bounded-serializer/component/BILL.json new file mode 100644 index 0000000000..5dcc474368 --- /dev/null +++ b/research/h25-bounded-serializer/component/BILL.json @@ -0,0 +1,76 @@ +{ + "schema": "h25-standalone-serializer-cost-bill-v1", + "status": "PREDECLARED_SOURCE_ONLY_NO_MEASUREMENT", + "guarded_budget": { + "owner": "Parent serialized queue only, after independent concrete operation admission", + "new_budget_created": false, + "existing_round_total_seconds": 2400, + "existing_initial_feasibility_seconds": 600, + "per_command_seconds": 180, + "sampled_memory_bytes": 1073741824, + "historical_usage_at_authorization_seconds": 63.770533479, + "all_failures_charged": true, + "automatic_retry_or_reroll": false + }, + "finite_control_bill": { + "modes": ["normal", "-O"], + "ordered_cases_per_mode": 70, + "ordered_cases_total": 140, + "case_cap_per_mode": 128, + "integer_bit_cap": 20000, + "retained_file_bytes_cap_per_mode_before_controls_json": 16777216, + "cap_exclusions_explicit": ["controls.json itself", "component-control-acceptance.json", "outer guard logs and independent receipts", "source package and authentication reads"], + "preserved_controls_source": "serialization_controls.py", + "fresh_inputs_and_roots": true, + "required_billing": [ + "Interpreter startup and standard-library/local imports; loader/source/binary custody scans and all before/after hashes", + "Exact reference code-clone setup and separate expected globals, fresh independent fixture construction, canonical oracle derivation", + "Original full encoding/hash/write and candidate factory/preflight/encoding/stage/hash/copy/cleanup for every applicable case", + "Callback hooks, changed digit settings and restoration, all injected failures including close/manifest failures", + "Freshness traversals and expected checks at factory/entry/exit boundaries, every real artifact readback, comparison and byte census", + "All retained original/candidate success and failure files, controls.json, additive acceptance receipt, outer logs and independent observer outputs", + "Independent validation and every failure/timeout within existing total wall/CPU/memory budget" + ], + "execution": "NOT_EXECUTED" + }, + "finite_consumer_bill": { + "allowed_support_rows": [0, 1, 1024, 1025, 2048], + "rank_events": 3, + "comparison_protocol": "Predeclare same rows; independent fresh process/root per baseline/candidate; baseline actual original writer clone, candidate actual production writer; external independent validation required", + "common_paid_costs": ["fixture creation", "finite expected computation with complete canonical encodings and hashes", "exact writer clone", "output mkdir", "writer execution", "local readback of all 3 artifacts", "local hash/size checks", "JSON receipt serialization/write", "stdout and complete outer close/exit", "parent before/after custody and independent comparisons"], + "baseline_extra_costs": ["eager complete encodings retained together until original receipt and writes complete"], + "candidate_extra_costs": ["candidate import and factory", "whole preflight and repeated per-batch bounds", "row slices, Unicode/ASCII batch objects, views and punctuation", "three stage writes and stage hashes", "copy reads plus copy hashes and final writes", "freshness traversals and complete expected equality", "successful cleanup or retained failure artifacts/manifest"], + "finite_expected_values": "Derived from this finite fixture only, never represented as complete H25 EXPECTED or independent scientific validation", + "performance_scope": "No measurement; any later finite result is limited to this actual consumer" + }, + "conditional_complete_three_artifact_bill": { + "condition": "Historical sizes only, conditional on genuine future complete equality; no artifact or caller read/execution in this author round", + "result_bytes": 527, + "witness_bytes": 58143622, + "rank_trace_bytes": 2674272, + "total_artifact_bytes": 60818421, + "baseline_final_write_bytes": 60818421, + "candidate_stage_write_bytes": 60818421, + "candidate_copy_read_bytes": 60818421, + "candidate_final_write_bytes": 60818421, + "candidate_total_write_bytes": 121636842, + "candidate_stage_hash_input_bytes": 60818421, + "candidate_copy_hash_input_bytes": 60818421, + "candidate_total_hash_input_bytes": 121636842, + "candidate_extra_full_copy_validation_read_bytes": 0, + "additional_independent_artifact_readback_bytes_per_complete_pass": 60818421, + "private_stage_disk_at_acceptance_bytes": 60818421, + "private_stage_plus_complete_final_disk_before_cleanup_bytes": 121636842, + "memory_boundary": "Eager witness input collections remain; bounded encoder batch/copy buffers do not imply a complete RSS bound or gain", + "unmeasured": ["wall time", "CPU including all children", "peak memory", "physical IO/cache effects", "syscall counts", "cleanup/error costs", "full original/candidate caller union costs"] + }, + "blocked_execution_conditions": [ + "Independent reviewer accepts exact package, reference extraction, actual consumer and fixed control order/count", + "Parent authenticates exact SOURCE-PINS manifest externally, actual loader/bootstrap/source bytes and before/after custody", + "Parent approves actual interpreter, standard-library and _json/hash constructor binary identities plus dynamic linked closure", + "Parent seals actual callable union; private fault injection is false for baseline/candidate consumer and any complete caller", + "Parent admits complete declared operations into existing serialized guard with complete charged resources and independent validation", + "Normal/-O controls, actual finite comparisons and measurements remain unexecuted; full H25 integration requires a separate complete consumer admission" + ], + "performance_claim": null +} diff --git a/research/h25-bounded-serializer/component/CONTROL-SPEC.json b/research/h25-bounded-serializer/component/CONTROL-SPEC.json new file mode 100644 index 0000000000..38c8aaa25b --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/FEASIBILITY.json b/research/h25-bounded-serializer/component/FEASIBILITY.json new file mode 100644 index 0000000000..1da6c4ed8c --- /dev/null +++ b/research/h25-bounded-serializer/component/FEASIBILITY.json @@ -0,0 +1,91 @@ +{ + "actual_baseline_call": "component_consumer.run_component(baseline) -> exact reference.write_scientific code cloned to separate finite EXPECTED globals -> original(root,*values)", + "actual_candidate_call": "component_consumer.run_component(candidate) -> bounded_serialization.make_writer -> writer(root,*values), faults false and BOUNDED_SERIALIZATION_PASS required", + "author_disposition": "GO_FOR_INDEPENDENT_SOURCE_REVIEW_ONLY", + "author_method": "Source reads, byte copies/extraction, AST parsing, JSON metadata and hashing only", + "blocked_conditions": "BILL.json blocked_execution_conditions", + "checkpoints": { + "F1": "AUTHOR_PREPARED_AWAITING_INDEPENDENT_ACCEPTANCE", + "F2": "PROPOSED_STANDALONE_GO_AWAITING_INDEPENDENT_ACCEPTANCE", + "F3": "AUTHORED_CONCRETE_COMPONENT_CONSUMER_AND_PACKAGE", + "F4": "AWAITING_INDEPENDENT_SOURCE_ACCEPTANCE", + "F5": "NOT_EXECUTED", + "F6": "NOT_EXECUTED", + "F7": "NO_MEASUREMENT_NO_PERFORMANCE_DISPOSITION", + "F8": "NO_PUBLICATION_BY_AUTHOR" + }, + "controls": { + "count_per_mode": 70, + "exact_order_source": "CONTROL-SPEC.json", + "execution": "NOT_EXECUTED", + "modes": [ + "normal", + "-O" + ] + }, + "execution_admission": false, + "execution_counts": { + "benchmarks": 0, + "compiler": 0, + "controls": 0, + "native": 0, + "scientific_runs": 0, + "target_imports": 0 + }, + "full_caller_relationship": "Finite independent component only; original complete H25 caller and complete artifacts not invoked or qualified", + "imports_by_source": { + "bounded_serialization.py": [ + "__future__", + "_json", + "contextlib", + "hashlib", + "json", + "json.encoder", + "os", + "pathlib", + "stat", + "tempfile", + "types" + ], + "component_consumer.py": [ + "__future__", + "argparse", + "bounded_serialization", + "hashlib", + "json", + "pathlib", + "reference", + "serialization_controls", + "sys", + "types" + ], + "reference.py": [ + "hashlib", + "json" + ], + "serialization_controls.py": [ + "__future__", + "bounded_serialization", + "copy", + "hashlib", + "json", + "pathlib", + "sys", + "types" + ] + }, + "independently_accepted": false, + "performance_claim": null, + "project_scientific_or_native_import_required": false, + "reference_excerpt_ast_and_byte_pins_verified": true, + "reviewed_code_unchanged": true, + "schema": "h25-serializer-component-author-feasibility-v1", + "scope_note": "One initial broad rg source search under outputs/h25-data-handling-20261028 returned static .py matches including that tree runtime/runs source copies; output truncated and not used for proposal. No h25-bookkeeping-swarm-20261028/runtime/runs target was searched/read. Subsequent reads explicit source paths only. No target code executed.", + "standalone_local_execution_closure": [ + "component_consumer.py", + "reference.py", + "bounded_serialization.py", + "serialization_controls.py", + "CONTROL-SPEC.json" + ] +} diff --git a/research/h25-bounded-serializer/component/ORIGINAL-SOURCE-PINS.json b/research/h25-bounded-serializer/component/ORIGINAL-SOURCE-PINS.json new file mode 100644 index 0000000000..1767b5809d --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/README.md b/research/h25-bounded-serializer/component/README.md new file mode 100644 index 0000000000..cb852a0ae6 --- /dev/null +++ b/research/h25-bounded-serializer/component/README.md @@ -0,0 +1,17 @@ +# Standalone bounded serializer component: source-only proposal + +Disposition proposed by the author: **GO for independent source-feasibility review; no execution admission**. The package is an additive extraction of the previously reviewed revision 3 serializer. No package module, helper, control, decoder, compiler, scientific caller or benchmark has run during authorship. AST parsing and metadata hashing only were used. This package cannot approve itself. + +The independently reviewed `bounded_serialization.py` and `serialization_controls.py` are copied byte for byte. `provenance/REVIEW-v3.json` is the exact earlier review. That review approves source conditionally on a concrete consumer and parent execution gate; it does not transfer runtime or performance approval to this package. Historical review files and proposal status strings are preserved verbatim. In particular `CONTRACT-v2.json` still says 65 controls and `SOURCE-READINESS-v3.json` still says pending source review: the governing revision 3 review and `CONTROL-SPEC.json` require exactly **70 ordered controls in each of normal and -O modes**, 140 total. The broader prose families in the old bill are not a claim that every listed variant exists in this concrete suite. + +`reference.py` contains exact source excerpts for `_RUNTIME_ERROR`, `require`, `canonical`, complete historical `EXPECTED`, and `write_scientific`. `REFERENCE-EXTRACTION.json` records original line spans and excerpt hashes. Whole original source files are archived under `provenance/` for independently checkable byte and AST comparison; they are never imported. The original baseline writer still eagerly canonicalizes all three objects, compares the unchanged receipt dictionary, writes result/witness/rank in original order, and returns original serialized sizes. The original `require` comes from `native_backend.py` and uses the preserved `_RUNTIME_ERROR = RuntimeError` binding. `canonical` comes from `profile_side_verifier.py`. No native backend or scientific module is needed by the extracted serializer reference. + +`component_consumer.py` provides the actual new finite consumer. Its baseline and candidate modes are separate guarded process invocations. Both construct fresh exact-schema fixture objects, derive a finite expected dictionary through the unchanged reference canonical function, and clone only the unchanged writer code into separate globals containing that finite dictionary. The module's complete historical `EXPECTED` is never changed. The candidate arm calls production `make_writer(original, reference.canonical, expected, reference.require, ...)`, requires faults to be disabled, calls the resulting `writer(root, *values)`, and requires bounded-path status. The baseline arm directly calls the unchanged writer clone and does not import candidate code. Both arms perform and pay a separate local artifact readback. Parent independent receipt/readback validation is still required. + +The finite fixture deliberately has at most 2048 support rows and three rank events. It exercises concrete independent usage and batch crossing, but does not represent the complete H25 caller or establish meaningful full-workload performance. Complete original artifact receipts, eager scientific witness construction, ordered complement coverage, typed return, stdout/certificate and combined native/source sealing remain separate original-goal requirements. + +Standalone dependency closure consists of these local execution sources: `component_consumer.py`, `reference.py`, `bounded_serialization.py`, `serialization_controls.py`, and `CONTROL-SPEC.json`. All imports outside that set are Python standard-library or builtin dependencies. No project scientific import, native build or parked cache dependency is needed for these finite modes. Actual supported Python/JSON callable shape, interpreter and extension binaries, loader/import path, standard-library bytes and linked binary closure still require parent custody approval before execution. This source package does not authenticate the installed runtime or arbitrary process memory. + +For review, the proposed future invocation shape is `python3 -B component_consumer.py --mode controls --output FRESH_EXTERNAL_PATH`, once normally and once with `-O`; baseline/candidate use the corresponding modes with the same `--rows` selection in separate fresh paths/processes. These are descriptions, not execution instructions authorized by this package. Parent alone owns the serialized guarded command queue, operation approval, exact source/manifest/bootstrap custody, independent validation, failure accounting and resource measurements. No proposed command creates a new budget. Failures and real file evidence must be retained without retry/reroll. + +`BILL.json` enumerates component and conditional complete-file costs. `SOURCE-PINS.json` freezes exact source/document/provenance bytes and modes; it must itself be authenticated from an external independent parent pin. No source-only status grants a runtime PASS, measured speed/memory gain, original-goal completion or publication qualification. The author owns no publication or PR action. diff --git a/research/h25-bounded-serializer/component/REFERENCE-EXTRACTION.json b/research/h25-bounded-serializer/component/REFERENCE-EXTRACTION.json new file mode 100644 index 0000000000..8a7e774b8e --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/SOURCE-PINS.json b/research/h25-bounded-serializer/component/SOURCE-PINS.json new file mode 100644 index 0000000000..91ff11fb41 --- /dev/null +++ b/research/h25-bounded-serializer/component/SOURCE-PINS.json @@ -0,0 +1,113 @@ +{ + "files": { + "BILL.json": { + "bytes": 5749, + "mode_octal": "0o444", + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + "CONTROL-SPEC.json": { + "bytes": 3062, + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "FEASIBILITY.json": { + "bytes": 3071, + "mode_octal": "0o444", + "sha256": "f9ff50549bae4071fb7531fe6ad2e53d2b593b8508d42dce6194ea7c3e012a61" + }, + "ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "README.md": { + "bytes": 5158, + "mode_octal": "0o444", + "sha256": "c74cc98f237a4ed97c77ec77555322b496c5e8a5f7544864dc55b584cc19a104" + }, + "REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "component_consumer.py": { + "bytes": 6761, + "mode_octal": "0o444", + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + "docs/API-v2.md": { + "bytes": 6025, + "mode_octal": "0o444", + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "docs/API-v3.md": { + "bytes": 2421, + "mode_octal": "0o444", + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "docs/CONTRACT-v2.json": { + "bytes": 2962, + "mode_octal": "0o444", + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "docs/COST-CONTROLS.json": { + "bytes": 11322, + "mode_octal": "0o444", + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "docs/SOURCE-READINESS-v3.json": { + "bytes": 773, + "mode_octal": "0o444", + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "provenance/PROPOSAL.json": { + "bytes": 7466, + "mode_octal": "0o444", + "sha256": "9bf3f21b0b2c3db755495e5b6c4ba1b6a76e18f43f8fc1563ae31a808a1ea0ee" + }, + "provenance/REVIEW-v3.json": { + "bytes": 7162, + "mode_octal": "0o444", + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + "provenance/SOURCE-DESIGN.md": { + "bytes": 5465, + "mode_octal": "0o444", + "sha256": "0a12cb7945e4bb772154346c61a202b9f44e7297800306ef9ce113373af77578" + }, + "provenance/compare_side_verifier.py": { + "bytes": 10571, + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "provenance/native_backend.py": { + "bytes": 20334, + "mode_octal": "0o444", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "provenance/profile_side_verifier.py": { + "bytes": 8959, + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "reference.py": { + "bytes": 2141, + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "runtime_or_performance_admission": false, + "schema": "h25-serializer-component-source-pins-v1", + "self_authentication": "This manifest requires external independent parent SHA256; manifest self-hash not embedded", + "status": "FROZEN_AUTHOR_SOURCE_PENDING_INDEPENDENT_REVIEW" +} diff --git a/research/h25-bounded-serializer/component/bounded_serialization.py b/research/h25-bounded-serializer/component/bounded_serialization.py new file mode 100644 index 0000000000..70c4587a67 --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/component_consumer.py b/research/h25-bounded-serializer/component/component_consumer.py new file mode 100644 index 0000000000..8445ab0bce --- /dev/null +++ b/research/h25-bounded-serializer/component/component_consumer.py @@ -0,0 +1,134 @@ +"""Concrete finite serializer consumer; parent admission is required to execute. + +Run in separate guarded processes for baseline and candidate. This module never +imports the complete scientific comparison or native backend. All output paths +must be fresh. It does not launch processes or measure itself. +""" +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +import sys +from types import FunctionType + +import reference + + +_NAMES = ("result.json", "witness.json", "rank-trace.json") + + +def fixture(rows): + """Small exact-schema input; this is not the complete H25 witness.""" + reference.require(type(rows) is int and rows in (0, 1, 1024, 1025, 2048), + "Unsupported finite fixture row count") + return ({"ok": True, "number": 3}, { + "support": list(range(rows)), "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 finite_reference(values): + """Same original code with separate finite EXPECTED, as in frozen controls.""" + 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({rows for rows, _ 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 original, expected + + +def run_component(mode, output_root, rows=2048): + """One concrete arm; no runtime permission or source custody is inferred.""" + reference.require(mode in ("baseline", "candidate", "controls"), "Invalid component arm") + reference.require(sys.flags.optimize in (0, 1), "Only normal and -O modes are declared") + root = Path(output_root) + reference.require(not root.exists(), "Refusing earlier component evidence") + if mode == "controls": + import serialization_controls + spec_path = Path(__file__).resolve().parent / "CONTROL-SPEC.json" + spec = json.loads(spec_path.read_text(encoding="utf-8")) + receipt = serialization_controls.run_controls(reference, root) + reference.require(receipt["case_count"] == spec["count_per_mode"] == 70, + "Component controls did not retain exactly 70 cases") + reference.require([row["case"] for row in receipt["cases"]] == spec["ordered_cases"], + "Component control order differs from frozen review") + reference.require(receipt["optimization"] == sys.flags.optimize, + "Component control optimization mode differs") + # Keep the exact original controls.json. Acceptance records are additive. + (root / "component-control-acceptance.json").write_text(json.dumps({ + "status": "COMPONENT_CONTROL_ORDER_CHECKED", + "case_count": 70, "optimization": sys.flags.optimize, + "scope": "Finite component only; requires independent parent validation", + }, sort_keys=True, indent=2) + "\n", encoding="utf-8") + return receipt + + # Input creation and finite oracle derivation are common paid setup in both + # arms. No previous artifact/receipt or successful PASS is read or reused. + values = fixture(rows) + original, expected = finite_reference(values) + root.mkdir(parents=True) + writer = original + if mode == "candidate": + import bounded_serialization + writer = bounded_serialization.make_writer( + original, reference.canonical, expected, reference.require, + batch_bytes=1048576, batch_rows=1024, copy_bytes=1048576) + reference.require(writer._h25_serialization_faults_enabled is False, + "Fault injection enabled in component candidate") + scientific_receipt = writer(root, *values) + if mode == "candidate": + reference.require(writer.last_operation["status"] == "BOUNDED_SERIALIZATION_PASS", + "Finite component candidate did not use bounded writer") + # Independent parent readback/comparison remains required. This finite local + # readback is charged and supplies concrete receipts, not source authority. + files = {} + for name, key, size_key in zip(_NAMES, + ("result_sha256", "exact_witness_sha256", "rank_trace_sha256"), + ("result", "witness", "rank_trace")): + raw = (root / name).read_bytes() + digest = hashlib.sha256(raw).hexdigest() + reference.require(digest == expected[key] == scientific_receipt[key], + "Finite artifact digest differs: " + name) + reference.require(len(raw) == scientific_receipt["serialized_bytes"][size_key], + "Finite artifact byte count differs: " + name) + files[name] = {"bytes": len(raw), "sha256": digest} + receipt = { + "status": "FINITE_SERIALIZER_COMPONENT_RETURNED", "mode": mode, + "optimization": sys.flags.optimize, "fixture_rows": rows, + "scientific_receipt": scientific_receipt, "files": files, + "candidate_operation": None if mode == "baseline" else writer.last_operation, + "scope": "Finite serializer fixture only; no complete H25 or performance qualification", + } + (root / "component-receipt.json").write_text(json.dumps(receipt, sort_keys=True, indent=2) + + "\n", encoding="utf-8") + return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--mode", choices=("controls", "baseline", "candidate"), required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--rows", type=int, choices=(0, 1, 1024, 1025, 2048), default=2048) + args = parser.parse_args() + receipt = run_component(args.mode, args.output, args.rows) + print(json.dumps({"status": receipt["status"], "mode": args.mode, + "optimization": sys.flags.optimize}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bounded-serializer/component/docs/API-v2.md b/research/h25-bounded-serializer/component/docs/API-v2.md new file mode 100644 index 0000000000..101bcc3a52 --- /dev/null +++ b/research/h25-bounded-serializer/component/docs/API-v2.md @@ -0,0 +1,49 @@ +# Area 3 implemented API, revision 2 + +Status: source and finite-control implementation authored; AST validation only. No scientific/module execution, compilation, control execution or timings by this lane. V1 proposal/API/control bill remain unchanged under reviewer snapshot. Parent admitted the following regular-file contract; this document supersedes the unresolved API points in v1. + +## Parent integration + +Place this lane on the isolated stage's module path and import `bounded_serialization`. After loading the authenticated original comparison module, construct: + +``` +writer = bounded_serialization.make_writer( + comparison.write_scientific, + comparison.canonical, + comparison.EXPECTED, + comparison.require, + batch_bytes=1048576, + batch_rows=1024, + copy_bytes=1048576, +) +``` + +The return is `writer(output, result, witness, rank_calls)`, returning exactly the original scientific receipt structure. Select it at the existing side-serialization phase in the candidate arm only. The reference arm retains its original function/module/process. Keep the existing eager witness, typed full return, certificate, stdout, complement checks and original source checks unchanged. The serializer owns only result.json, witness.json and rank-trace.json in the supplied side-observation directory. + +Create the writer and finish all closure/guard assembly before final sealing. `writer._h25_serialization_bindings` is a tuple of `(owner, attribute_name, captured_object)` entries for actual JSON and _json modules/class attributes. Some entries are classes or Python functions, so this tuple is NOT the native-only entry protocol. `writer._h25_serialization_faults_enabled` must be False in a complete caller. The writer checks these identities plus original function code/default/closure identities and relevant original global bindings on every call. Parent must separately authenticate source and actual runtime binary custody; upstream CPython source is not a binary attestation. Expected-receipt mutation is rejected on every call. There is no scientific PASS cache. + +`writer.last_operation` is the supplemental JSON-safe operational record. Read it after success, or in the parent's failure handling if desired; do not add it to the frozen scientific receipt. It includes status, phase, staging path, configured bounds, batch count/largest batch, per-file stage/hash/copy byte counts, original/copy digests, cleanup progress and bounded error metadata. A successful record's stage path names the now-removed private stage. Literal fallback records status only. This mutable reporting attribute is not consulted by computation or acceptance. + +## Admission and literal fallback + +Exact known witness dictionaries, exact list/tuple arrays and scalar leaves, exact rank list/event tuples/integers, depth and byte bounds are freshly checked. Output must be an exact local Path whose destination directory and preexisting final files fit the regular-file contract. Unsupported argument/object domains invoke the untouched original function with untouched arguments before candidate writes or conversion callbacks. The supported fast caller is source-checked, single-threaded and frozen; arbitrary concurrent mutation and arbitrary file-like sinks are not promised. Missing/nonregular/symlink destinations use original behavior. There is no fixed-word integer cap; original Python decimal conversion and digit-limit exceptions remain. + +## Accepted publication and failure semantics + +Generate all three private staged artifacts and hashes, compute original rank counts, and require the original EXPECTED equality before changing a final filename. Copy into regular binary `wb` files in original result/witness/rank order. Each bounded write must return precisely its requested length; otherwise raise OSError without retry. Synthetic short-return behavior intentionally differs from the original caller, which ignored its single write's return value. Actual OS failure-prefix length may differ with chunking; no stronger equivalence is claimed. + +Every copy rehashes/counts its existing read stream, checks source fstat/path identity/size/timestamps before and after reading, and checks final size. After streams close, require copy digest/count equal to the accepted staged values. No additional full read is performed. A rejected copy can leave its corrupt/partial final visible, earlier finals intact and later names absent. It cannot return a success receipt or remove its failure evidence. Successful stages are removed only after all copies pass. Actual IO exceptions propagate; close/manifest failures do not mask an existing primary exception. Failure manifests remain inside the unique private stage, bounded at 64 KiB. + +## Controls + +Import `serialization_controls` and call: + +``` +receipt = serialization_controls.run_controls(comparison, fresh_external_control_directory) +``` + +This must run only in the parent's guarded serial queue after G1, once per required normal/-O finite arm. The supplied comparison module is the unchanged reference. Controls reconstruct separate fixtures, clone its exact writer code into separate globals only to supply finite EXPECTED values, and never edit the imported reference module. All complete scientific original/candidate comparisons still run in separate processes. Controls preserve raw failure files and write controls.json. They start no compiler, scientific import, complete caller or timer themselves. + +The private `_make_writer(..., fault=...)` test seam exists exclusively for injected finite IO controls. Production `make_writer` has no fault argument. Faults permit deterministic errors/short returns/content corruption while preserving actual regular files; they are not a production file-like API. + +Full expected bytes/hashes remain those in PROPOSAL.json: 527-byte result, 58,143,622-byte witness, 2,674,272-byte rank trace; 59,959 rank calls and 252 distinct matrices. Future full results must establish all of them afresh. No measured gain exists yet. diff --git a/research/h25-bounded-serializer/component/docs/API-v3.md b/research/h25-bounded-serializer/component/docs/API-v3.md new file mode 100644 index 0000000000..5f49cbe68f --- /dev/null +++ b/research/h25-bounded-serializer/component/docs/API-v3.md @@ -0,0 +1,14 @@ +# Area 3 implemented API revision 3 + +This revision retains every API, regular-file contract, scientific pin and cost item in API-v2.md and CONTRACT-v2.json. The production and control filenames remain `bounded_serialization.py` and `serialization_controls.py`. Exact v2 source/doc bytes are preserved under `versions/v2/`; no v2 receipt or historical measurement was changed. + +The factory call and `writer.last_operation` interface are unchanged. Add the following source-bound checks to the integration contract: + +- The original writer, canonical encoder and require function must be ordinary closure-free functions with no defaults. This is their inspected source shape. Unsupported reference function shapes are rejected at factory creation. +- Capture JSON function code, effective globals/builtins, defaults and keyword-default entries, including names in nested code objects. Check absence of formerly missing globals to reject new shadows. Capture the JSONEncoder class dictionary and actual hashlib SHA constructor in addition to prior JSON/_json bindings. +- Fast-path freshness runs at entry, before success cleanup, and immediately before returning the successful receipt. Literal fallback delegates first, then checks freshness before returning success. A fallback callback that mutates bound runtime dependencies can retain its original output files but now raises; status is `FALLBACK_EXIT_FRESHNESS_FAILED`. Arbitrary mutating-runtime callback equivalence was never admitted. +- Original exception paths still propagate their primary errors. The added exit checks do not replace a failed original fallback's exception or delete evidence. Guard checks never treat the reporting attribute as an authority. + +These checks add captured dependency/keyword/class metadata, setup inspection of code names, and three bounded freshness traversals per successful fast write or two per successful literal fallback. This is charged overhead; there is no timing claim. Complete caller/native arithmetic does not invoke these checks on every arithmetic boundary. + +The finite runner now has 70 expected cases from source: v2's 65 plus effective builtin drift, new JSON global shadowing, keyword-default content drift, late fast-path drift and successful-fallback runtime drift. Parent alone executes the normal/-O finite suite and full original/candidate comparison. This lane has performed only AST/JSON/source/hash checks. diff --git a/research/h25-bounded-serializer/component/docs/CONTRACT-v2.json b/research/h25-bounded-serializer/component/docs/CONTRACT-v2.json new file mode 100644 index 0000000000..003fadd098 --- /dev/null +++ b/research/h25-bounded-serializer/component/docs/CONTRACT-v2.json @@ -0,0 +1,43 @@ +{ + "schema": "h25-serialization-implementation-contract-v2", + "status": "SOURCE_READY_PARENT_EXECUTION_ONLY", + "prior_documents": ["PROPOSAL.json", "SOURCE-DESIGN.md", "API.md", "COST-CONTROLS.json"], + "prior_documents_unchanged": true, + "admission": "Parent explicitly authorized implementation with reviewer regular-file/short-write/copy-rehash contract", + "production_api": "bounded_serialization.make_writer(comparison.write_scientific, comparison.canonical, comparison.EXPECTED, comparison.require, *, batch_bytes=1048576, batch_rows=1024, copy_bytes=1048576)", + "writer_api": "writer(output,result,witness,rank_calls) -> unchanged scientific receipt", + "supplemental_receipt": "writer.last_operation", + "control_api": "serialization_controls.run_controls(comparison, fresh_external_output_root)", + "control_case_count_expected_from_source": 65, + "control_cap_cases": 128, + "control_retained_file_cap_bytes_before_controls_json": 16777216, + "control_execution_status": "NOT_EXECUTED", + "regular_file_failure_contract": { + "order": ["result.json", "witness.json", "rank-trace.json"], + "short_write": "Require exact full requested count; else OSError without retry", + "declared_difference": "Original single-write caller ignored return count; exact kernel failure-prefix length is not invariant under chunking", + "original_exception": "Actual IO errors propagate; secondary close/manifest errors do not mask primary", + "failure_retention": "Earlier completed finals, failing prefix/corrupt final and private stage remain; later finals not opened", + "cleanup": "Successful stage removed only after all copies close and compare; no deletion of old-run evidence" + }, + "stage_integrity": "Record fstat identity/mode/size/mtime/ctime at generation; compare path and opened descriptor before and after copy; rehash/count existing copy reads and compare after close; final regular-file size checked", + "full_io_and_hash_bill": { + "exact_total_bytes_if_unchanged": 60818421, + "stage_write_bytes": 60818421, + "staged_copy_read_bytes": 60818421, + "final_write_bytes": 60818421, + "stage_hash_input_bytes": 60818421, + "copy_verification_hash_input_bytes": 60818421, + "total_hash_input_bytes": 121636842, + "total_write_bytes": 121636842, + "extra_full_read_in_candidate": 0, + "notes": "Retains v1 complete bill; adds copy hash work, file metadata checks and bounded manifests. Independent parent artifact validation read costs remain separate. No fsync or crash-atomicity promise." + }, + "scope_limitations": [ + "Eager witness secondary lists retained in this first implementation", + "Literal fallback retains original unbounded allocations", + "No arbitrary file-like or concurrent-mutating caller equivalence claim", + "Parent owns actual source/runtime binary custody and combined guard sealing", + "No measured wall/CPU/RSS result; all scientific comparisons/tests remain parent-only" + ] +} diff --git a/research/h25-bounded-serializer/component/docs/COST-CONTROLS.json b/research/h25-bounded-serializer/component/docs/COST-CONTROLS.json new file mode 100644 index 0000000000..f7a8e4126e --- /dev/null +++ b/research/h25-bounded-serializer/component/docs/COST-CONTROLS.json @@ -0,0 +1,86 @@ +{ + "schema": "h25-serialization-cost-control-bill-v1", + "status": "PREDECLARED_NOT_EXECUTED", + "execution": { + "owner": "Parent serial queue only, after G1 bounded-log gate", + "finite_fixture_total_output_cap_bytes": 16777216, + "finite_case_count_cap": 128, + "large_scalar_fixture_bit_cap": 20000, + "serialization_limits": {"batch_bytes": 1048576, "batch_rows": 1024, "copy_bytes": 1048576, "admitted_depth": 32}, + "modes": ["normal", "-O"], + "reference": "Separate untouched original canonical/write_scientific functions and freshly constructed independent fixture objects", + "no_shared_pass": true, + "resource_caps": "Parent plan: <=180 s per scientific command, sampled 1 GiB, total initial 600 s / round 2400 s including failures; no retry or timing reroll", + "finite_counts_note": "128 cases maximum per mode; exact enumerated count must be frozen in admitted controls before execution. No combinatorial cross product." + }, + "retained_costs": [ + "All original scientific computation, assertions, runtime/native freshness checks and call coverage", + "All original eager witness object/list construction, including basis item snapshots and pieces", + "Every ordered witness/rank record and all canonical bytes; original rank length and distinct-row set calculation", + "Result encoding, all actual Python decimal/Unicode/nested conversions and configured integer digit-limit enforcement", + "Three complete artifact hashes and exact EXPECTED dictionary rejection", + "Final result/witness/rank writes in original order and their successful close", + "Typed full return, CLI certificate/stdout, ordered complement transcript, before/after source custody and original controls" + ], + "new_costs": [ + "Factory and actual json runtime/source binding checks, helper import and per-invocation fresh admission", + "Whole-schema callback-free type/cycle/depth/record-size preflight", + "Repeated per-record upper-bound calculation during batching if no retained plan", + "Bounded exact list slices, batch dictionaries/encoder objects, punctuation, Unicode buffers, ASCII byte copies and memoryviews", + "Incremental hashlib updates for every produced fragment; digest state and byte counters", + "Unique private stage creation and all staging writes, flushes/closes and disk capacity", + "Bounded staged reads and final writes; no cached artifact substitutes for fresh serialization", + "Short-write/error accounting, final close, successful stage unlink/rmdir, failed-stage manifests and cleanup exceptions", + "Every finite/negative control, independent source review, full original/candidate replay and measurement", + "Any final-file readback/hash equality checks explicitly added by parent; count separately rather than hiding as output-free validation", + "Fallback admission overhead plus complete original encoder/write costs for unsupported cases" + ], + "full_io_bill": { + "historical_exact_total_bytes_per_three_artifacts": 60818421, + "baseline_final_write_bytes": 60818421, + "candidate_stage_write_bytes": 60818421, + "candidate_staged_read_bytes": 60818421, + "candidate_final_write_bytes": 60818421, + "candidate_total_write_bytes": 121636842, + "candidate_canonical_digest_input_bytes": 60818421, + "reference_or_parent_independent_readback_bytes_per_pass": 60818421, + "transient_stage_disk_bytes_at_acceptance": 60818421, + "transient_stage_plus_complete_final_disk_bytes_before_cleanup": 121636842, + "note": "These counts are arithmetic from historical exact sizes, conditional on identical future outputs. Allocation/RSS, wall/CPU, filesystem cache, syscall counts and cleanup costs are unmeasured." + }, + "controls": [ + {"id": "S01", "kind": "finite-positive", "case": "Empty/singleton and ordinary known-schema artifacts", "assert": "Exact original bytes, all digest/size/count receipt fields and final filenames"}, + {"id": "S02", "kind": "finite-positive", "case": "Non-sorted input dict insertion with exact string keys; ordered source/output/basis list pairs", "assert": "Only dictionary keys sort; all list/tuple event order remains original"}, + {"id": "S03", "kind": "finite-positive", "case": "0, -1, positive/negative integers around 2^53 and 2^64, 2300-bit and 20000-bit values under explicitly restored digit settings", "assert": "No precision loss or fixed-word truncation; byte-for-byte original decimal output or same original exception"}, + {"id": "S04", "kind": "finite-positive", "case": "ASCII quote/backslash/control characters, BMP, astral characters and isolated surrogates", "assert": "ensure_ascii exact escapes, compact separators and no trailing newline"}, + {"id": "S05", "kind": "finite-positive", "case": "None, booleans, exact finite floats, negative zero, NaN and signed infinities in schema-compatible test leaves", "assert": "Original type distinctions and literal JSON tokens; no normalization"}, + {"id": "S06", "kind": "finite-boundary", "case": "Array lengths 0, 1, 1023, 1024, 1025 and 2048 with total fixture cap", "assert": "No extra/missing commas/brackets, duplicate records or dropped last record"}, + {"id": "S07", "kind": "finite-boundary", "case": "Byte-bound partition immediately below, equal to and above batch upper bound; oversized one-record fallback", "assert": "Batch bounds honored, whole-record order preserved; fallback output/error equal to original"}, + {"id": "S08", "kind": "finite-positive", "case": "Repeated immutable rank row references versus separately equal rows", "assert": "Every rank call retained; same rank length/distinct count, bytes and caller references"}, + {"id": "S09", "kind": "finite-negative", "case": "Exact list/tuple nesting at depth boundary and one deeper; circular list and circular dict", "assert": "Literal fallback before file action; original recursion/circular error type/message preserved"}, + {"id": "S10", "kind": "finite-negative", "case": "dict/list/tuple/int/str/float subclasses with observing or raising hooks, nested in each major artifact position", "assert": "No callbacks during candidate preflight; original callback count/order and exception from separately reconstructed input"}, + {"id": "S11", "kind": "finite-negative", "case": "Unknown objects, mixed incomparable dictionary keys, supported non-string keys and missing/unexpected schema keys", "assert": "Literal fallback; original unsupported/sort behavior and successful non-string-key behavior preserved"}, + {"id": "S12", "kind": "finite-negative", "case": "Integer decimal-digit boundary and one beyond configured limit; restore setting in finally", "assert": "Same original ValueError type/message, no ordinary final files on conversion failure"}, + {"id": "S13", "kind": "finite-negative", "case": "Failed result encoding, failed witness encoding, failed rank encoding independently", "assert": "No final files before all encodings/counts/expected checks pass; retain staged successful prefixes"}, + {"id": "S14", "kind": "finite-negative", "case": "Wrong expected result/witness/rank digest independently, wrong rank count and wrong distinct count", "assert": "Original rejection message and no final-file modifications"}, + {"id": "S15", "kind": "finite-negative", "case": "Injected hashing update failure at first/middle/final fragment", "assert": "Error escapes, produced/persisted prefix accounting explicit, no accepted receipt and no finals"}, + {"id": "S16", "kind": "file-negative", "case": "Stage directory creation/open/write/flush/close failures at bounded checkpoints", "assert": "Primary error preserved, descriptors closed, partial staging evidence retained, no finals"}, + {"id": "S17", "kind": "file-negative", "case": "Final open/write/flush/close failure in result, witness and rank independently", "assert": "Original final publication order; earlier completed finals preserved, failing prefix retained, later names untouched"}, + {"id": "S18", "kind": "file-negative", "case": "Controlled short-positive and zero final writes, and byte-budget ENOSPC-style failure", "assert": "Explicit admitted short-write policy; compare original observable failure/result behavior; disclose syscall-prefix differences"}, + {"id": "S19", "kind": "file-negative", "case": "Staged read error or staged content mutation between generation and copy", "assert": "No silent success; exact final readback or before-copy integrity requirement receives parent review; retain affected evidence"}, + {"id": "S20", "kind": "file-negative", "case": "Cleanup unlink/rmdir and failure-manifest write failure", "assert": "No earlier-run cleanup; primary exception not masked; visible residual path/secondary failure retained"}, + {"id": "S21", "kind": "file-positive", "case": "Successful stage lifecycle with all final files closed", "assert": "Exact final bytes and original receipt; no orphan successful temporary stage"}, + {"id": "S22", "kind": "file-negative", "case": "Existing parent run output plus direct-call preexisting final files", "assert": "Parent refuses earlier run overwrite before helper; direct-call wb behavior preserved; expected rejection leaves old bytes unchanged"}, + {"id": "S23", "kind": "source-negative", "case": "Original canonical/json encoder/helper binding replacement between factory capture and writer invocation", "assert": "Source-bound rejection before output, no stale admitted PASS or accidental Python-path silent substitution"}, + {"id": "S24", "kind": "state-positive", "case": "Compare all fixture containers and reference identities before/after writer; repeat invocation on independently changed supported input", "assert": "No input mutation, hidden persistent answer cache or stale digest reuse"}, + {"id": "S25", "kind": "full", "case": "Parent runs complete unchanged reference and admitted candidate in distinct processes", "assert": "Exact 58143622B witness and 2674272B rank artifacts, all expected hashes, typed return, stdout, certificate, 59959 ranks, 252 distinct matrices and original complement coverage"}, + {"id": "S26", "kind": "full-resource", "case": "Predeclared same-session old/new full protocol after complete control union", "assert": "Outer wall/CPU/peak RSS and all cold costs recorded; preserve every sample/failure; do not infer from batch size alone"}, + {"id": "S27", "kind": "full-closure", "case": "Normal/-O finite controls plus full original assertion-on invocation in combined stage", "assert": "Actual serializer consumer, all helper/runtime identities sealed before execution, before/after source custody exact"} + ], + "unresolved_before_implementation": [ + "Reviewer/parent must approve bounded final copy semantics and decide exact short-write behavior; original Path.write_bytes is one buffered write and ignores its return count at caller", + "Stage tampering checks must be concrete: private process-owned files and same descriptors are baseline assumption; any independent readback/hash is an added full cost, never silently omitted", + "Actual runtime _json binary and callable authentication belongs to parent closure; upstream source commit alone is not runtime identity", + "Finite control exact case enumeration and bounded admission metadata must be frozen with implementation" + ] +} diff --git a/research/h25-bounded-serializer/component/docs/SOURCE-READINESS-v3.json b/research/h25-bounded-serializer/component/docs/SOURCE-READINESS-v3.json new file mode 100644 index 0000000000..11ccff2165 --- /dev/null +++ b/research/h25-bounded-serializer/component/docs/SOURCE-READINESS-v3.json @@ -0,0 +1,26 @@ +{ + "compilations": 0, + "control_cases_expected_from_source": 70, + "files": { + "API-v3.md": { + "bytes": 2421, + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "bounded_serialization.py": { + "bytes": 23560, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "serialization_controls.py": { + "bytes": 23684, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "finite_runs": 0, + "full_runs": 0, + "previous_version": "versions/v2/", + "review_status": "PENDING_INDEPENDENT_SOURCE_REVIEW", + "schema": "h25-serialization-source-readiness-v3", + "scientific_imports": 0, + "status": "AST_ONLY_NOT_EXECUTED", + "timings": 0 +} diff --git a/research/h25-bounded-serializer/component/provenance/PROPOSAL.json b/research/h25-bounded-serializer/component/provenance/PROPOSAL.json new file mode 100644 index 0000000000..9f044aebfe --- /dev/null +++ b/research/h25-bounded-serializer/component/provenance/PROPOSAL.json @@ -0,0 +1,89 @@ +{ + "schema": "h25-data-handling-proposal-v1", + "area": 3, + "status": "AWAITING_SOURCE_ADMISSION_NO_IMPLEMENTATION", + "title": "Exact-schema bounded batches through the original CPython C JSON encoder", + "baseline": { + "publication_commit": "e05aad954689d0ee21baff19b4674f1fcb2e838f", + "stage": "outputs/h25-bookkeeping-swarm-20261028/stages/v4", + "stage_sha256_from_parent_plan": "558eebbc1dc65e42bbcb3ffd9973f8bc86641a3539493ecc1d53d8077c39cdbc", + "source_hashes": { + "integration/full_driver.py": "5b963a5f108b334a627e68001c80b9843fb300c7394693e72f34ce0a6050e6f1", + "baseline/engine/compare_side_verifier.py": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68", + "baseline/engine/source/complex_circuit.py": "d623617f7c5cb3189580883a8ab30c0bd3832688ae3f1f0c1f881bbbbff8e0c1" + }, + "historical_artifacts": { + "result": {"bytes": 527, "sha256": "342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c"}, + "witness": {"bytes": 58143622, "sha256": "4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82"}, + "rank_trace": {"bytes": 2674272, "sha256": "85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f"} + }, + "historical_c1_serialization_wall_seconds": 1.2042208680068143, + "historical_c1_kernel_max_rss_kib": 453852, + "evidence_boundary": "Historical bounded receipt reads only; no candidate measurements and no independent reconstruction in this lane" + }, + "primary_sources": { + "local_json_encoder": {"path": "/usr/lib/python3.12/json/encoder.py", "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869"}, + "local_json_init": {"path": "/usr/lib/python3.12/json/__init__.py", "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5"}, + "local_pathlib": {"path": "/usr/lib/python3.12/pathlib.py", "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d"}, + "local_patchlevel": {"path": "/usr/include/python3.12/patchlevel.h", "sha256": "f2f4800f05108bef77f6164484aba437b86b81e34744cbb5378f7bb2ccc69414", "version": "3.12.3"}, + "cpython_release": "https://github.com/python/cpython/commit/f6650f9ad73359051f3e558c2431a109bc016664", + "cpython_json_c": "https://github.com/python/cpython/blob/f6650f9ad73359051f3e558c2431a109bc016664/Modules/_json.c", + "cpython_json_c_evidence_lines": ["1189-1215 one complete Unicode writer result", "1309-1313 Python integer repr", "1479-1494 sorted dict items", "1526-1590 ordered sequence encoding"], + "runtime_boundary": "Upstream source explains mechanism; it is not attestation of the distro's compiled _json binary. Parent must bind/authenticate actual runtime dependencies before execution." + }, + "source_research_failure": { + "command": "bounded curl download of CPython release source to lane reference directory", + "exit_code": 6, + "stderr": "curl: (6) Could not resolve host: raw.githubusercontent.com", + "resolution": "No command retry; used read-only web primary source plus exact release commit. No fetched source bytes or source hash claimed." + }, + "domain": { + "primary": "Frozen exact witness schema, exact builtin containers/scalars, no cycles, depth <=32, bounded per-record encoded upper bound", + "integer_policy": "No fixed-word integer restriction; original Python decimal conversion and int max-str-digits behavior retained", + "fallback": "Before IO, invoke separately retained untouched original write_scientific with original arguments for any unadmitted domain", + "bounded_memory_scope": "Admitted path only; original fallback can retain original full allocations", + "concurrency": "Source-checked frozen single-thread caller; arbitrary concurrent mutation is outside admitted domain" + }, + "batching": { + "max_rows": 1024, + "max_encoded_upper_bound_bytes": 1048576, + "max_depth": 32, + "copy_buffer_bytes": 1048576, + "canonical_options": {"sort_keys": true, "separators": [",", ":"], "ensure_ascii": true}, + "implementation": "Exact list batches encoded by ordinary json.dumps C path; only outer array brackets omitted via memoryview and commas inserted between batches", + "key_order": ["active", "args", "code", "kind", "labels", "pieces", "support"], + "code_key_order": ["gates", "outputs", "roles", "sources"], + "estimators": {"int": "bit_length*30103//100000+2", "str": "12*len+2", "float": 32, "containers": "sum recursive child bounds plus punctuation"} + }, + "interfaces": { + "writer": "make_writer(reference_write_scientific,reference_canonical,expected,require,...)->writer(output,result,witness,rank_calls)", + "rank": "Exact builtin list remains unchanged; rows may be interned immutable exact tuples; no new interface", + "reference": "Separate original module/function/process; never rebind original writer or canonical encoder", + "integration": "Parent selects candidate writer at existing side serialization phase; eager witness construction initially unchanged", + "observations": "Return original receipt only; separate bounded operational receipt preserves scientific stdout/schema" + }, + "output_contract": { + "serialization_order": ["result", "witness", "rank_trace"], + "acceptance": "Compute original rank counts and entire EXPECTED comparison after all three staged encodings, before any final file changes", + "final_order": ["result.json", "witness.json", "rank-trace.json"], + "publication": "Bounded copy into original wb final sinks, preserving completed files and failing prefix; no atomic rename", + "failure_evidence": "Retain private partial stage and bounded failure manifest; retain any visible partial final; cleanup errors cannot mask original error", + "success_cleanup": "Remove only this call's private stage after all final writes close successfully", + "declared_differences": ["Added staging IO failures", "Different final syscall grouping and possibly different OS failure prefix length", "Short-write behavior must receive explicit source-review disposition before implementation"] + }, + "reserve_mechanisms": [ + {"name": "Python JSONEncoder.iterencode", "status": "RESERVE", "reason": "Bounded chunks but Python per-token work may regress; no timing performed"}, + {"name": "C encoder iterencode(_one_shot=True) on whole witness", "status": "REJECTED", "reason": "CPython source returns one complete Unicode object"}, + {"name": "Lazy labels/pieces projection", "status": "DEFERRED_AFTER_FIRST_MEMORY_RESULT", "reason": "Avoids secondary lists but changes eager conversion order; needs separate owner/descriptor/failure contract"}, + {"name": "Custom native bounded serializer", "status": "RESERVE", "reason": "Adds cold compilation, integer/escaping/sorting parity and binding obligations"}, + {"name": "Stage mmap passed to original Path.write_bytes", "status": "RESERVE_ONLY", "reason": "Preserves single final write but mapped pages can charge whole-file RSS"} + ], + "required_before_implementation": ["Parent source admission", "Independent reviewer approval of explicit final-write/short-write boundary", "Actual runtime/source closure binding"], + "execution_owner": "Parent serial guarded queue after log-fix gate", + "new_scientific_runs": 0, + "new_compilations": 0, + "new_measurements": 0, + "performance_claim": null, + "cost_and_controls": "COST-CONTROLS.json", + "owned_future_files": ["bounded_serialization.py", "serialization_controls.py"] +} diff --git a/research/h25-bounded-serializer/component/provenance/REVIEW-v3.json b/research/h25-bounded-serializer/component/provenance/REVIEW-v3.json new file mode 100644 index 0000000000..c438b6467d --- /dev/null +++ b/research/h25-bounded-serializer/component/provenance/REVIEW-v3.json @@ -0,0 +1,152 @@ +{ + "area": "serialization", + "billing": [ + "Conditional full output60818421B: stage writes and final writes each60818421B; copy reads60818421B; hash input121636842B.", + "Preflight/repeated bounds, batches/slices, setup/freshness traversal, both writes, copy hash, cleanup, failed stages and independent readback all charged.", + "No wall/CPU/RSS saving is established by source shape or bounded batch size." + ], + "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." + ], + "disposition": "SOURCE_APPROVED_PENDING_CONCRETE_PARENT_CONSUMER_AND_EXECUTION_GATE", + "execution_admission": false, + "expected_control_case_count_per_mode": 70, + "expected_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" + ], + "findings": [ + "Derivation preserves sorted-key compact ASCII bytes for exact admitted witness schema, ordering within arrays and original integer/float/Unicode conversion behavior; unknown/callback-bearing domains delegate to original writer.", + "Whole preflight and per-batch bounds avoid full encoded witness materialization; eager witness collections remain allocated.", + "All three stages plus exact expected digest/count equality precede final-file publication. Accepted regular-file contract preserves original file order, with explicit short-write rejection and potentially different kernel failure prefixes.", + "Every copied byte is rehashed and counted through existing bounded reads; staged identity and original accepted digest are checked, with no hidden extra full read.", + "Primary IO errors survive secondary close/manifest failures; failed prefixes and stages remain, and successful cleanup follows validated final copies.", + "Revision3 checks effective builtins, absence of globals, nested JSON code-name bindings, JSON class and mutable keyword-default entries, original closure-free function identities, and source expected receipt.", + "Freshness runs at entry, before success cleanup, and immediately before fast return; literal fallback checks exit after original succeeds. Original fallback errors retain their primary exception.", + "Concrete70-case control source uses separate original/candidate fixture objects, exact original function code with separate finite EXPECTED globals, and retained real files for fault controls.", + "Parent source/binary custody and actual combined callable sealing remain essential; this source review does not authenticate an arbitrary runtime or hostile process-memory environment." + ], + "finite_caps": { + "batch_bytes_max": 1048576, + "batch_rows_max": 1024, + "case_cap": 128, + "copy_bytes_max": 1048576, + "integer_bits": 20000, + "retained_file_bytes_before_controls_json": 16777216 + }, + "implementation_revision": 3, + "required_next": [ + "Parent freezes exact loader/source/binary custody, original reference shape and actual candidate writer call in combined source; reviewer approves concrete consumer and union.", + "Require all70 ordered controls per normal/O mode, retain all failures and check actual full artifact receipts independently.", + "Preserve original baseline writer and source; no successful full caller with private fault injection enabled." + ], + "review_method": "Source, AST and exact hashes only; no controls, scientific import, compilation or timing executed by reviewer.", + "reviewed_files": { + "areas/serialization/API-v2.md": { + "bytes": 6025, + "mode": 436, + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "areas/serialization/API-v3.md": { + "bytes": 2421, + "mode": 436, + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "areas/serialization/CONTRACT-v2.json": { + "bytes": 2962, + "mode": 436, + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "areas/serialization/COST-CONTROLS.json": { + "bytes": 11322, + "mode": 436, + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "areas/serialization/SOURCE-READINESS-v3.json": { + "bytes": 773, + "mode": 436, + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "areas/serialization/bounded_serialization.py": { + "bytes": 23560, + "mode": 436, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "areas/serialization/serialization_controls.py": { + "bytes": 23684, + "mode": 436, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "schema": "h25-independent-implementation-source-review-v1" +} diff --git a/research/h25-bounded-serializer/component/provenance/SOURCE-DESIGN.md b/research/h25-bounded-serializer/component/provenance/SOURCE-DESIGN.md new file mode 100644 index 0000000000..59db437ac7 --- /dev/null +++ b/research/h25-bounded-serializer/component/provenance/SOURCE-DESIGN.md @@ -0,0 +1,29 @@ +# Area 3: bounded exact witness serialization + +Status: source proposal only; no implementation, scientific imports, compilation, decoding, timing or performance claim. + +The immutable baseline is PR6029 `e05aad954689d0ee21baff19b4674f1fcb2e838f`, stage v4. `integration/full_driver.py:322-333` eagerly constructs the witness; `baseline/engine/compare_side_verifier.py:74-94` encodes result, witness and rank trace completely, hashes them, checks EXPECTED, then writes final files in that order. Historical C1 records 527 / 58,143,622 / 2,674,272 bytes and 1.204220868 seconds for serialization. These are historical observations, not candidate results. + +## Source findings + +Local `/usr/lib/python3.12/json/encoder.py` selects the C encoder only when `_one_shot` is true and indentation is absent. `encode` joins its result. Upstream CPython [commit f6650f9ad73359051f3e558c2431a109bc016664](https://github.com/python/cpython/commit/f6650f9ad73359051f3e558c2431a109bc016664), tagged 3.12.3, [Modules/_json.c](https://github.com/python/cpython/blob/f6650f9ad73359051f3e558c2431a109bc016664/Modules/_json.c) uses one Unicode writer and returns a one-element tuple after completion (1189-1215). Its integer branch uses Python integer representation (1309-1313); sorted dictionaries sort their items (1479-1494). Calling C `iterencode` on the whole witness therefore does not stream. Python `iterencode` does stream, but adds Python work per token; its time is unmeasured here. + +## Proposed mechanism + +Keep eager witness construction unchanged for the first candidate. Admit only the exact known witness schema, exact built-in containers/scalars, no cycles, bounded nesting and bounded per-record encoding. A callback-free preflight traverses exact containers using built-in operations. Subclasses, unfamiliar shapes, unsupported leaves, excessive depth or oversized records select the separately retained literal original `write_scientific` before any file action. Arbitrary-width integers have no machine-word restriction: use Python's original decimal conversion, including its configured digit-limit errors. The admitted streaming memory bound does not apply to literal fallback. + +Visit top-level keys in canonical order: active, args, code, kind, labels, pieces, support; code keys: gates, outputs, roles, sources. Preserve every sequence item and every basis/source/output insertion order already captured as lists. Encode batches of at most 1,024 records and a conservative 1 MiB encoded upper bound with the unchanged `json.dumps(..., sort_keys=True, separators=(',', ':'), ensure_ascii=True)` expression. Remove only each batch's outer array brackets using a memoryview; insert precisely one comma between nonempty batches. Empty arrays remain `[]`. No JSON parsing, numeric recoding, new C extension or alternate serializer is required. + +The estimator is callback-free: exact integer bound is `bit_length*30103//100000+2`; string bound is `12*len+2`; exact floats use a conservative 32-byte bound; containers add punctuation and child bounds. Cap depth at 32. Oversized single records use literal fallback. The result retains its original complete encoder; its frozen size is only 527 bytes. The rank lane confirmed that rank_calls remains an exact list of exact tuple rows/result events; existing length and distinct-matrix expressions remain unchanged. + +## Files and failures + +Encode result, witness and rank into a unique private stage, incrementally hashing every exact byte. Check the complete EXPECTED dictionary before exposing any ordinary final artifact. On a serialization, count or digest failure, leave ordinary final files untouched and retain staged prefixes plus a bounded failure manifest. Do not retry or convert exceptions into success. + +After acceptance, copy staged files using bounded buffers into final `wb` sinks in the original result/witness/rank order. Preserve already completed finals and a failing final's prefix; never delete failure evidence. Success removes private stage files. Failure closes handles, retains its stage and records cleanup errors without masking the primary exception. Parent output-directory rejection remains unchanged. This preserves the semantic ordering and failure-prefix contract, but changes syscall grouping and adds stage IO failures; those differences require reviewer admission and explicit controls. Atomic rename is rejected because it removes the original partial-final-write behavior. An mmap plus original single write is a reserve only: it can count whole-file pages toward RSS. + +## Further memory reduction and gate + +Lazy labels/pieces projection could avoid their complete secondary lists. It also moves original eager property accesses and conversion failures into serialization order. Defer it until this candidate's measured memory and cost justify that extra source-bound contract; do not claim its savings. Generic Python streaming remains a reserve if batching regresses. A custom native encoder adds integer/escaping parity and cold-build obligations, so it is not the initial candidate. + +Admission requires independent source review, all controls in COST-CONTROLS.json, exact old/new complete files and unchanged original encoder execution in a distinct process. Charge preflight, repeated bounds, all conversions, hashes, stage/final writes, reads, cleanup and source custody. Final full runs measure wall/CPU/peak RSS under the parent queue. No speed or memory factor is promised. diff --git a/research/h25-bounded-serializer/component/provenance/compare_side_verifier.py b/research/h25-bounded-serializer/component/provenance/compare_side_verifier.py new file mode 100644 index 0000000000..d94920c274 --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/provenance/native_backend.py b/research/h25-bounded-serializer/component/provenance/native_backend.py new file mode 100644 index 0000000000..77e55ce9d0 --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/provenance/profile_side_verifier.py b/research/h25-bounded-serializer/component/provenance/profile_side_verifier.py new file mode 100644 index 0000000000..807855eb87 --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/reference.py b/research/h25-bounded-serializer/component/reference.py new file mode 100644 index 0000000000..2c60da3ae8 --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/component/serialization_controls.py b/research/h25-bounded-serializer/component/serialization_controls.py new file mode 100644 index 0000000000..7ace093a93 --- /dev/null +++ b/research/h25-bounded-serializer/component/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-bounded-serializer/reviews/ACCEPTANCE-CHECKLIST-v1.md b/research/h25-bounded-serializer/reviews/ACCEPTANCE-CHECKLIST-v1.md new file mode 100644 index 0000000000..7538269d06 --- /dev/null +++ b/research/h25-bounded-serializer/reviews/ACCEPTANCE-CHECKLIST-v1.md @@ -0,0 +1,48 @@ +# Fixed serializer acceptance checklist, revision 1 + +Scope: the directly authorized independent serializer stream. This is a source-only review checklist; execution remains parent-only in the single guarded queue. Frozen predecessor source approval is `outputs/h25-data-handling-20261028/review/serialization-v3-source/REVIEW.json`. Its exact70 concrete cases, not the broader prose families, remain the immutable case specification. Review uses source/AST/ordinary metadata hashing only. The goal service remains separately paused, and the historical cache stream remains paused49/52. + +## F1 source, reference and control closure + +- All seven approved files must match the frozen reviewer hashes, byte lengths and modes. Do not replace approved controls or candidate implementation with a rewritten approximation. The independent current verification is `SOURCE-CLOSURE-v1.json`. +- Preserve the exact original `write_scientific` block and literal historical `EXPECTED` from baseline `compare_side_verifier.py` SHA256 `6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68`. +- Preserve exact `canonical` from `profile_side_verifier.py` SHA256 `9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a`, and exact `require` plus `_RUNTIME_ERROR=RuntimeError` binding from `native_backend.py` SHA256 `e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5`. +- Excerpt hashes and line boundaries must be recorded and checked independently. Extraction may parse source but must not import the complete comparison/profile/native modules. Preserve original functions as closure-free ordinary functions without defaults. +- Standalone component closure may include only concrete consumer, literal extracted reference, reviewed candidate/control sources, frozen source evidence and ordinary standard library dependencies. Any decoder, native build, scientific construction/full caller, parked observer/cache bridge or protected historical run is a new dependency and blocks this narrow route. +- Exact ordered70-case names are frozen in `SOURCE-CLOSURE-v1.json`. Existing review count70/API-v3 supersedes the earlier contract's historical65 count without changing that predecessor file. + +## F2 standalone feasibility and bill + +- Define a concrete standalone input/consumer and its limited claim. Ordinary finite fixtures do not constitute full H25 artifacts or a complete scientific caller. +- Define exact normal/optimized commands, fresh retained output directories, source/binary custody checks, wall/CPU/memory measurement boundary and all failure charging before execution. Parent queue policy remains2400s total/initial600s/180s per command/sampled1GiB, historical usage63.770533479s at authorization, no retry/reroll. +- Runtime execution admission is a separate parent gate. Source feasibility acceptance cannot self-authorize target imports/tests. If the existing guard cannot admit the concrete standalone package without a parked dependency, freeze a supported NO-GO. +- Do not hide setup/import/closure/freshness work, repeated admission bounds, batch slices/encodings, complete original reference controls, staging, copy, hashes, cleanup, failed attempts, independent readback or metadata publication. All retained eager fixture/witness/rank allocations count. + +## F3/F4 concrete source and consumer + +- Manifest every executable package file, loader, literal reference and immutable control specification by bytes/hash; freeze concrete invocation and exact bytes before review. No mutable path fallback or implicit caller import. +- Reference arm remains untouched exact source. Finite EXPECTED values may be supplied only via separate function globals as in the approved controls; preserve the literal historical EXPECTED independently. Never mutate imported original reference state. +- Candidate must actually call public `make_writer` with approved bounds and unchanged `canonical`, `write_scientific`, `require`; its `_h25_serialization_faults_enabled` must be False outside finite fault controls. Any separate concrete comparison writer must use this actual candidate function, not fixture receipts alone. +- Preserve fresh expected validation, actual module/callable/builtins/default/keyword/class bindings and entry/precleanup/exit freshness checks. Capture actual interpreter, libpython/_json/_hashlib or crypto extension dependencies and standard library source path identities through the parent's reviewed custody mechanism; a CPython source commit alone is insufficient. +- Check the consumer's own exact case-order/count assertion, output directory refusal, mode validation and failure exit behavior. No success receipt before independent required checks complete; no `assert`-only acceptance in optimized mode. +- Source review emits an exact-byte ACCEPT or REJECT with scope and defects. Feasibility acceptance, implementation acceptance and runtime admission remain separate records. + +## F5/F6 finite execution controls + +- Execute exactly all70 ordered cases once in normal mode and once in optimized mode, retaining all raw directories/partial files/failure evidence and controls.json. Verify count and complete ordered names against frozen independent list, normal optimization0 and optimized optimization1, without importing target code into the review process. +- Verify independent original/candidate fixture identities, exact byte outcomes and callback order, input preservation and no stale PASS on changed input. Verify distinct-row count preserves duplicate rank events. +- Confirm unsupported/callback/cyclic/deep/malformed/non-string domains delegate before candidate conversion/file effects; preserve original errors and digit-limit restoration. +- Confirm all staged artifacts and exact receipt equality precede finals; publication order is result/witness/rank. Short writes fail without retry. Kernel failure-prefix lengths may differ under chunking, and original ignored short-return counts; these declared differences remain visible. +- Verify source/staged descriptor/path identity and size/timestamps, bounded copy rehash/count equality, final sizes and failure retention. Primary exceptions survive secondary close/manifest errors. Successful cleanup occurs only after validated copies. +- Preserve the admitted70-case coverage boundary: no separately claimed tuple/str/float subclass, circular-dict, all-artifact-position subclass cross product, middle/final-fragment hash injection, ENOSPC byte-budget or all missing/extra-schema-key variants. + +## F7 comparison and complete cost disposition + +- Retain baseline/candidate exact outputs, independent hashes/bytes/counts, actual operational counters, outer wall, total CPU and peak-memory evidence for the declared finite consumer and both mode/control attempts. Disclose regressions or no saving. Source shape/bounded batches alone establish no speed or RSS gain. +- Whole-H25 historical sizes527+58143622+2674272=60818421B are conditional future expectations only. At that size candidate stage writes60818421B, staged reads60818421B, final writes60818421B, stage hash60818421B plus copy hash60818421B; total writes121636842B and hash input121636842B. Independent artifact readback costs another60818421B per complete readback pass. Maximum stage+final disk before cleanup121636842B, excluding all other evidence. +- A finite fixture comparison must use its actual sizes and bill, never substitute historical whole-H25 bytes. No arbitrary repeated timing trials; fixed complete bill and retained first attempt(s). + +## F8 publication and whole-H25 boundary + +- Parent handles isolated additive publication, contribution guidance, upstream exact-head hosted checks and handoff readback. A source-only draft must state no execution/performance qualification. Reviewer does no PR follow-up. +- This stream alone does not qualify complete H25 original/candidate artifact equality, full59,959rank calls/252distinct matrices,238,685complement events, typed full return, CLI stdout/certificate, shared-observer interaction, source/native arithmetic guards, full-caller normal execution, whole-resource totals, PR5864 gain, new construction, kappa or original six-area goal gates. Those require genuine separately admitted complete caller evidence. diff --git a/research/h25-bounded-serializer/reviews/F1-REVIEW-v1.json b/research/h25-bounded-serializer/reviews/F1-REVIEW-v1.json new file mode 100644 index 0000000000..9a7dad1a6b --- /dev/null +++ b/research/h25-bounded-serializer/reviews/F1-REVIEW-v1.json @@ -0,0 +1,88 @@ +{ + "accepted_scope": "Authenticated source/reference/control closure only: seven frozen reviewed source/doc files verified; candidate/control exact bytes and 70 ordered specification preserved; all five literal reference blocks exactly match source-pinned predecessor; concrete standalone stdlib import closure inspected without target imports.", + "blocking_defects_in_accepted_scope": [], + "checkpoint": "F1", + "created_utc": "2026-10-31T04:26:43.839024+00:00", + "disposition": "ACCEPT", + "evidence": { + "review/ACCEPTANCE-CHECKLIST-v1.md": { + "bytes": 8241, + "mode": 436, + "sha256": "1e1c5061fc92325b0fc09b7a0f2f3c0b2e9e9e6b6eaafa6630fb172e608dbf37" + }, + "review/PRELIMINARY-SOURCE-CHECK-v1.json": { + "bytes": 2168, + "mode": 436, + "sha256": "7ff6296d0b7801028a35581bb3ec946f0d52a4edcffd9202a5919f4c96e21f65" + }, + "review/SOURCE-CLOSURE-v1.json": { + "bytes": 7993, + "mode": 436, + "sha256": "b066021ebdd16e4e146deb0af732c1257e87c96b41a56da75a87ac2204848033" + }, + "serializer/CONTROL-SPEC.json": { + "bytes": 3062, + "mode": 436, + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "serializer/REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "mode": 436, + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "serializer/bounded_serialization.py": { + "bytes": 23560, + "mode": 436, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "serializer/provenance/REVIEW-v3.json": { + "bytes": 7162, + "mode": 436, + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + "serializer/provenance/compare_side_verifier.py": { + "bytes": 10571, + "mode": 436, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "serializer/provenance/native_backend.py": { + "bytes": 20334, + "mode": 436, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "serializer/provenance/profile_side_verifier.py": { + "bytes": 8959, + "mode": 436, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "serializer/reference.py": { + "bytes": 2141, + "mode": 436, + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "serializer/serialization_controls.py": { + "bytes": 23684, + "mode": 436, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "execution_admission": false, + "findings": [ + "All seven current approved files match original reviewer byte lengths, modes and hashes.", + "Candidate source 4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb and control source 72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09 are preserved.", + "Reference canonical/require/write_scientific and EXPECTED plus _RUNTIME_ERROR retain exact source blocks and AST.", + "Standalone executable import closure consists of authored consumer/reference/reviewed helper/controls and stdlib; scientific/native provenance files are read-only evidence and must never be imported.", + "Fixed70 ordered controls are unchanged; required later execution is70normal+70optimized." + ], + "method": "Source inspection, AST parsing and ordinary metadata hashing only; no target execution, tests, process inspection, native/compiler/decoder/science or protected historical run reads.", + "outside_acceptance": [ + "Final package manifest and exact concrete consumer F4 acceptance", + "Standalone execution route/admission, interpreter identity and honest environment custody evidence", + "All target imports/tests/controls/performance execution", + "Full original H25 caller/artifacts/shared-observer/native/binary qualification", + "Any original-goal gate, resource/performance gain, mathematical or kappa admission" + ], + "schema": "serializer-independent-F1-review-v1", + "source_implementation_acceptance": false, + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/reviews/F2-REVIEW-v1.json b/research/h25-bounded-serializer/reviews/F2-REVIEW-v1.json new file mode 100644 index 0000000000..69f7e6105a --- /dev/null +++ b/research/h25-bounded-serializer/reviews/F2-REVIEW-v1.json @@ -0,0 +1,81 @@ +{ + "accepted_scope": "Standalone source-feasibility GO with fixed validation bill, existing bounded parent route and no parked scientific dependency. Runtime source/binary/admission and actual command custody remain mandatory independent gates.", + "bill": { + "bytes": 5749, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/BILL.json", + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + "blocking_defects_in_accepted_scope": [], + "checkpoint": "F2", + "cost_disposition": [ + "All4 declared operation attempts including failures charged to existing budget; no retry or timing reroll.", + "Both finite comparison arms pay fixture creation, complete canonical+hash finite expected derivation, exact original code clone, real writer execution, complete local artifact readback/hash, receipt/stdout/exit.", + "Candidate additionally pays import/factory, complete preflight and repeated bounds, slices/encodings, stage writes/hashes, copy reads/hash/final writes, metadata/freshness checks and cleanup or retained failure evidence.", + "All before/after source/binary custody, complete70normal+70optimized controls, independent parent readback/hash/comparison, guard/log/accounting metadata and outer exit costs are charged separately, never assumed zero.", + "Budget remains2400s total/initial600s/180s command/sampled1GiB; historical charged usage63.770533479s remains. Existing policy adds2s nominal admin and0.01s rounding/attempt; physicaltailunknown remains open.", + "Finite fixture actual artifact sizes must be read from fresh receipts/readback. Conditional historical wholeH25 counts in BILL remain expectations only." + ], + "created_utc": "2026-10-31T04:28:39.643374+00:00", + "disposition": "ACCEPT", + "execution_admission": false, + "fixed_operation_plan": [ + { + "arm": "controls", + "case_count": 70, + "fresh_process_and_root": true, + "optimization": 0 + }, + { + "arm": "controls", + "case_count": 70, + "fresh_process_and_root": true, + "optimization": 1 + }, + { + "arm": "baseline", + "fresh_process_and_root": true, + "optimization": 0, + "rank_events": 3, + "support_rows": 2048 + }, + { + "arm": "candidate", + "fresh_process_and_root": true, + "optimization": 0, + "rank_events": 3, + "support_rows": 2048 + } + ], + "frozen_inventory_check": { + "bytes": 4124, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/FROZEN-PACKAGE-CHECK-v1.json", + "sha256": "3f1271d0a14eac1e65c835f96b9c939ae4eb02cdd404239e19d48d50ce630ff2" + }, + "method": "Independent source/manual review, AST and exact byte/mode/hash checks only. No target imports/execution/tests/native/compiler/decoder/science/process inspection or protected historical run reads.", + "milestone_type": "INDEPENDENTLY_ACCEPTED_STANDALONE_SOURCE_FEASIBILITY_ONLY", + "outstanding_before_execution": [ + "Exact frozen stage/adapter/JOBS/runner inventory and one-use actual command/output custody independently reviewed", + "Actual interpreter identity plus standard-library/JSON/hash/linked-library custody evidence and explicit supported finite environment assumption; no claim of original whole-runtime binary attestation", + "Parent admission into existing serial guard with fresh current budget reconciliation and complete operation accounting" + ], + "package_manifest": { + "bytes": 3914, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/SOURCE-PINS.json", + "sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" + }, + "performance_qualification": false, + "preserved_original_requirements": [ + "Exact70 ordered controls in both normal and optimized modes before runtime-control qualification", + "Unchanged original reference writer/canonical/require/EXPECTED and candidate/control bytes", + "Freshness/expected guards, bounded source/copy identity/count/hash verification and failure evidence retention", + "Parent source/runtime custody and actual consumer callable closure, faults false outside finite fault controls", + "Complete genuine caller evidence for every original whole-H25 requirement" + ], + "route": { + "bytes": 3279, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/PARENT-ROUTE-ASSESSMENT-v1.json", + "sha256": "e93782a30ad5f4aaa98e1ea0dff225082b415a26554ed7ac644a0593a02f92ca" + }, + "schema": "serializer-independent-component-review-v1", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/reviews/F4-REVIEW-v1.json b/research/h25-bounded-serializer/reviews/F4-REVIEW-v1.json new file mode 100644 index 0000000000..4db13babfc --- /dev/null +++ b/research/h25-bounded-serializer/reviews/F4-REVIEW-v1.json @@ -0,0 +1,57 @@ +{ + "accepted_scope": "Exact frozen standalone serializer package and concrete finite consumer source implementation. Public candidate writer is actually invoked; baseline retains exact original code in separate finite EXPECTED globals. This approves source implementation only.", + "blocking_defects_in_accepted_scope": [], + "checkpoint": "F4", + "consumer": { + "bytes": 6761, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/component_consumer.py", + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + "created_utc": "2026-10-31T04:28:39.643374+00:00", + "disposition": "ACCEPT", + "execution_admission": false, + "frozen_inventory_check": { + "bytes": 4124, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/FROZEN-PACKAGE-CHECK-v1.json", + "sha256": "3f1271d0a14eac1e65c835f96b9c939ae4eb02cdd404239e19d48d50ce630ff2" + }, + "method": "Independent source/manual review, AST and exact byte/mode/hash checks only. No target imports/execution/tests/native/compiler/decoder/science/process inspection or protected historical run reads.", + "milestone_type": "INDEPENDENTLY_ACCEPTED_COMPONENT_SOURCE_IMPLEMENTATION_ONLY", + "outstanding_before_runtime_or_performance": [ + "Parent exact staged adapter/command/source/runtime custody and separately approved execution gate", + "Execute and independently check70normal+70optimized controls", + "Fresh fixed2048-row baseline/candidate operations with exact output equality and full measured costs", + "Genuine complete caller integration/equality/resource evidence for any original whole-H25 claim" + ], + "package_manifest": { + "bytes": 3914, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/SOURCE-PINS.json", + "sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" + }, + "performance_qualification": false, + "preserved_original_requirements": [ + "Exact70 ordered controls in both normal and optimized modes before runtime-control qualification", + "Unchanged original reference writer/canonical/require/EXPECTED and candidate/control bytes", + "Freshness/expected guards, bounded source/copy identity/count/hash verification and failure evidence retention", + "Parent source/runtime custody and actual consumer callable closure, faults false outside finite fault controls", + "Complete genuine caller evidence for every original whole-H25 requirement" + ], + "reference": { + "bytes": 2141, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/serializer/reference.py", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "schema": "serializer-independent-component-review-v1", + "source_checks": [ + "All21 manifest payload files match exact hashes/lengths/modes; manifest external pin verified. All10 original source pins independently match current source metadata.", + "All5 extracted blocks exactly match predecessor source spans and AST; historical EXPECTED remains literal and unchanged.", + "Candidate/control files retain approved exact bytes; CONTROL-SPEC retains exact70 ordered names and coverage gaps.", + "Actual candidate make_writer factory call uses approved1MiB/1024rows/1MiB limits, rejects faults enabled and requires BOUNDED_SERIALIZATION_PASS. Baseline does not import candidate implementation.", + "Controls call unchanged runner on extracted original reference, require exact70 count/order and optimization, keep controls.json unchanged with additive acceptance metadata.", + "Separate fresh output paths refused if already present; finite original clone uses separate globals rather than mutating reference.EXPECTED.", + "Acceptance uses ordinary require checks and remains active under -O. Ordinary fixture restricts0/1/1024/1025/2048rows and3rank events; does not represent complete H25.", + "README/BILL preserve accepted failure/regular-file semantics, complete costs, original control coverage gaps, runtime/source custody and whole-caller requirements.", + "Package mode hardening from preparation to final0444/0555 is explicit; it does not alter source bytes. F1 evidence records the earlier preparation modes and is superseded for executable package mode custody by this final manifest." + ], + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/reviews/FROZEN-PACKAGE-CHECK-v1.json b/research/h25-bounded-serializer/reviews/FROZEN-PACKAGE-CHECK-v1.json new file mode 100644 index 0000000000..5f250c7de8 --- /dev/null +++ b/research/h25-bounded-serializer/reviews/FROZEN-PACKAGE-CHECK-v1.json @@ -0,0 +1,120 @@ +{ + "actual": { + "BILL.json": { + "bytes": 5749, + "mode_octal": "0o444", + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + "CONTROL-SPEC.json": { + "bytes": 3062, + "mode_octal": "0o444", + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "FEASIBILITY.json": { + "bytes": 3071, + "mode_octal": "0o444", + "sha256": "f9ff50549bae4071fb7531fe6ad2e53d2b593b8508d42dce6194ea7c3e012a61" + }, + "ORIGINAL-SOURCE-PINS.json": { + "bytes": 3032, + "mode_octal": "0o444", + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "README.md": { + "bytes": 5158, + "mode_octal": "0o444", + "sha256": "c74cc98f237a4ed97c77ec77555322b496c5e8a5f7544864dc55b584cc19a104" + }, + "REFERENCE-EXTRACTION.json": { + "bytes": 2031, + "mode_octal": "0o444", + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "bounded_serialization.py": { + "bytes": 23560, + "mode_octal": "0o444", + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "component_consumer.py": { + "bytes": 6761, + "mode_octal": "0o444", + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + "docs/API-v2.md": { + "bytes": 6025, + "mode_octal": "0o444", + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "docs/API-v3.md": { + "bytes": 2421, + "mode_octal": "0o444", + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "docs/CONTRACT-v2.json": { + "bytes": 2962, + "mode_octal": "0o444", + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "docs/COST-CONTROLS.json": { + "bytes": 11322, + "mode_octal": "0o444", + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "docs/SOURCE-READINESS-v3.json": { + "bytes": 773, + "mode_octal": "0o444", + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "provenance/PROPOSAL.json": { + "bytes": 7466, + "mode_octal": "0o444", + "sha256": "9bf3f21b0b2c3db755495e5b6c4ba1b6a76e18f43f8fc1563ae31a808a1ea0ee" + }, + "provenance/REVIEW-v3.json": { + "bytes": 7162, + "mode_octal": "0o444", + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + "provenance/SOURCE-DESIGN.md": { + "bytes": 5465, + "mode_octal": "0o444", + "sha256": "0a12cb7945e4bb772154346c61a202b9f44e7297800306ef9ce113373af77578" + }, + "provenance/compare_side_verifier.py": { + "bytes": 10571, + "mode_octal": "0o444", + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "provenance/native_backend.py": { + "bytes": 20334, + "mode_octal": "0o444", + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "provenance/profile_side_verifier.py": { + "bytes": 8959, + "mode_octal": "0o444", + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "reference.py": { + "bytes": 2141, + "mode_octal": "0o444", + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "serialization_controls.py": { + "bytes": 23684, + "mode_octal": "0o444", + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "all_python_AST_parse": true, + "created_utc": "2026-10-31T04:28:03.003890+00:00", + "defects": [], + "frozen_directory_mode": "0555", + "frozen_file_mode": "0444", + "manifest_exact": true, + "method": "AST and metadata hashes only; no target imports/execution/tests", + "original_source_pins_checked": 10, + "payload_files": 21, + "schema": "serializer-frozen-package-independent-inventory-v1", + "source_pins_sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" +} diff --git a/research/h25-bounded-serializer/reviews/PARENT-ROUTE-ASSESSMENT-v1.json b/research/h25-bounded-serializer/reviews/PARENT-ROUTE-ASSESSMENT-v1.json new file mode 100644 index 0000000000..e4f3067791 --- /dev/null +++ b/research/h25-bounded-serializer/reviews/PARENT-ROUTE-ASSESSMENT-v1.json @@ -0,0 +1,48 @@ +{ + "created_utc": "2026-10-31T04:27:11.327864+00:00", + "disposition": "FEASIBLE_EXISTING_BOUNDED_ROUTE_PENDING_CONCRETE_ADMISSION", + "evidence": { + "outputs/h25-stable-packages-publication-20261031/control/ADMISSION-archive-normal.json": { + "bytes": 2594, + "sha256": "9f68bd0ba8195b69b208f4881ccfedb3ef623de54779d2669b2ceb345b17fa50" + }, + "outputs/h25-stable-packages-publication-20261031/control/VALIDATION-LEDGER-006.json": { + "bytes": 3988, + "sha256": "df16cd790ef27f3008399d73ea2ad068d2fab7e844a713fd96244430ed3e7b2a" + }, + "outputs/h25-stable-packages-publication-20261031/validation/run_guarded.py": { + "bytes": 12110, + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + }, + "outputs/h25-stable-packages-publication-20261031/validation/stages/lossless-evidence-archive-v2/JOBS.json": { + "bytes": 150, + "sha256": "d4a2c8db7785102e6ad9bf6803ba8ee1b8b2cf2aec5be7cd8e71fa181846a138" + }, + "outputs/h25-stable-packages-publication-20261031/validation/stages/lossless-evidence-archive-v2/integration/full_driver.py": { + "bytes": 593, + "sha256": "b68b90306b76f1af67b535c1664005f7bea24fd2ac435d7df43987d3607be2fd" + } + }, + "method": "Read-only bounded source/metadata review; no process inspection, target import, target execution, tests, native/compiler/science or PR follow-up.", + "minimal_new_sources": [ + "A fresh stage integration/full_driver.py adapter translating frozen finite job names to component_consumer.py modes, rejecting nonfinite invocation and optimization mismatch", + "A fresh JOBS.json describing controls-normal/controls-optimized and fixed fixture baseline/candidate arms", + "Exact STAGE.json inventory tying package/adapter/jobs to unchanged guard hash", + "One-use admission for every actual command, output path and current charged budget" + ], + "reusable_guards": [ + "Parent outer global science.lock flock -n and existing runner local lock prevent concurrent work", + "Outer GNU time and timeout178s+kill3; runner180s sampled1GiB and2MiB each stdout/stderr", + "Immutable whole stage bytes/modes before and after execution; exact runner hash; fresh output evidence refusal", + "Current usage from ledger63.770533479s is preserved with2s nominal administrative charge and0.01s GNU rounding per attempt; unknown physical tail remains open" + ], + "runtime_admission": false, + "schema": "serializer-parent-route-source-assessment-v1", + "scope_limits": [ + "Existing guard checks fractions.py source but does not authenticate whole interpreter/_json/crypto binary dependencies. New admission must pin actual interpreter identity and retain honest finite-environment assumption or concrete custody evidence; no inherited whole-H25 binary authentication is claimed.", + "No source-only route assessment admits execution. Parent must independently review exact staged adapter/package/jobs/commands and applicable accounting/ownership gates.", + "Stable-package finite route does not require existing complete scientific driver/native/decoder/parked observer/caching imports.", + "Existing runtime directories or protected historical runs were not inspected in this assessment." + ], + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/reviews/PRELIMINARY-SOURCE-CHECK-v1.json b/research/h25-bounded-serializer/reviews/PRELIMINARY-SOURCE-CHECK-v1.json new file mode 100644 index 0000000000..999f0c3c4a --- /dev/null +++ b/research/h25-bounded-serializer/reviews/PRELIMINARY-SOURCE-CHECK-v1.json @@ -0,0 +1,87 @@ +{ + "approved_candidate_sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb", + "approved_controls_sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09", + "consumer_sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1", + "control_count": 70, + "control_order_matches": true, + "imports": { + "bounded_serialization.py": [ + "__future__", + "_json", + "contextlib", + "hashlib", + "json", + "json.encoder", + "os", + "pathlib", + "stat", + "tempfile", + "types" + ], + "component_consumer.py": [ + "__future__", + "argparse", + "bounded_serialization", + "hashlib", + "json", + "pathlib", + "reference", + "serialization_controls", + "sys", + "types" + ], + "reference.py": [ + "hashlib", + "json" + ], + "serialization_controls.py": [ + "__future__", + "bounded_serialization", + "copy", + "hashlib", + "json", + "pathlib", + "sys", + "types" + ] + }, + "method": "AST and hashes only; no target imports or execution", + "reference_excerpts": [ + { + "ast_equal": true, + "reference_excerpt_exact": true, + "source_hash_matches_record": true, + "source_span_matches": true, + "symbol": "_RUNTIME_ERROR" + }, + { + "ast_equal": true, + "reference_excerpt_exact": true, + "source_hash_matches_record": true, + "source_span_matches": true, + "symbol": "require" + }, + { + "ast_equal": true, + "reference_excerpt_exact": true, + "source_hash_matches_record": true, + "source_span_matches": true, + "symbol": "canonical" + }, + { + "ast_equal": true, + "reference_excerpt_exact": true, + "source_hash_matches_record": true, + "source_span_matches": true, + "symbol": "EXPECTED" + }, + { + "ast_equal": true, + "reference_excerpt_exact": true, + "source_hash_matches_record": true, + "source_span_matches": true, + "symbol": "write_scientific" + } + ], + "reference_sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" +} diff --git a/research/h25-bounded-serializer/reviews/REVIEW-FREEZE-v1.json b/research/h25-bounded-serializer/reviews/REVIEW-FREEZE-v1.json new file mode 100644 index 0000000000..c00ceee233 --- /dev/null +++ b/research/h25-bounded-serializer/reviews/REVIEW-FREEZE-v1.json @@ -0,0 +1,61 @@ +{ + "accepted_checkpoints": [ + "F1 source/reference/control closure", + "F2 standalone source feasibility and fixed validation bill", + "F4 concrete package/consumer source implementation" + ], + "execution_admission": false, + "execution_counts": { + "native_compiler_decoder_science": 0, + "target_imports": 0, + "tests_or_controls": 0 + }, + "feasibility_deadline_utc": "2026-10-31T04:52:41.875537Z", + "files": { + "ACCEPTANCE-CHECKLIST-v1.md": { + "bytes": 8241, + "mode_octal": "0o444", + "sha256": "1e1c5061fc92325b0fc09b7a0f2f3c0b2e9e9e6b6eaafa6630fb172e608dbf37" + }, + "F1-REVIEW-v1.json": { + "bytes": 4161, + "mode_octal": "0o444", + "sha256": "5af6f4c4e17be4c64d4897a9a6cef63d7bfe95d8846419d9ee66fbc8e3d2750a" + }, + "F2-REVIEW-v1.json": { + "bytes": 4666, + "mode_octal": "0o444", + "sha256": "6a26b3a29132cb2ef1af67d270c5d7aa2a021ac53583f0129e1fcdce9ea61361" + }, + "F4-REVIEW-v1.json": { + "bytes": 4439, + "mode_octal": "0o444", + "sha256": "856e5f2b7af1fd28fe047657c3f2fd994cc59ab3c5a1549e82f55ab706c8eb3d" + }, + "FROZEN-PACKAGE-CHECK-v1.json": { + "bytes": 4124, + "mode_octal": "0o444", + "sha256": "3f1271d0a14eac1e65c835f96b9c939ae4eb02cdd404239e19d48d50ce630ff2" + }, + "PARENT-ROUTE-ASSESSMENT-v1.json": { + "bytes": 3279, + "mode_octal": "0o444", + "sha256": "e93782a30ad5f4aaa98e1ea0dff225082b415a26554ed7ac644a0593a02f92ca" + }, + "PRELIMINARY-SOURCE-CHECK-v1.json": { + "bytes": 2168, + "mode_octal": "0o444", + "sha256": "7ff6296d0b7801028a35581bb3ec946f0d52a4edcffd9202a5919f4c96e21f65" + }, + "SOURCE-CLOSURE-v1.json": { + "bytes": 7993, + "mode_octal": "0o444", + "sha256": "b066021ebdd16e4e146deb0af732c1257e87c96b41a56da75a87ac2204848033" + } + }, + "frozen_utc": "2026-10-31T04:29:00.953899+00:00", + "future_review_policy": "These exact files are frozen; any future adapter/admission/runtime evidence review must use additive separately named records. Directory intentionally remains writable for additive owned reviews.", + "remaining": "Parent exact stage/adapter/command/runtime custody and execution admission;70normal+70optimized controls; fixed2048-row baseline/candidate comparison and full costs; scoped publication. FullH25 requirements remain separate.", + "schema": "serializer-independent-review-freeze-v1", + "status": "SOURCE_FEASIBILITY_AND_IMPLEMENTATION_ACCEPTED_BEFORE_DEADLINE" +} diff --git a/research/h25-bounded-serializer/reviews/SOURCE-CLOSURE-v1.json b/research/h25-bounded-serializer/reviews/SOURCE-CLOSURE-v1.json new file mode 100644 index 0000000000..d18b89af72 --- /dev/null +++ b/research/h25-bounded-serializer/reviews/SOURCE-CLOSURE-v1.json @@ -0,0 +1,180 @@ +{ + "all_approved_bytes_match": true, + "approved_files": { + "outputs/h25-data-handling-20261028/areas/serialization/API-v2.md": { + "bytes": 6025, + "matches_frozen_review": true, + "mode": 436, + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "outputs/h25-data-handling-20261028/areas/serialization/API-v3.md": { + "bytes": 2421, + "matches_frozen_review": true, + "mode": 436, + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "outputs/h25-data-handling-20261028/areas/serialization/CONTRACT-v2.json": { + "bytes": 2962, + "matches_frozen_review": true, + "mode": 436, + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "outputs/h25-data-handling-20261028/areas/serialization/COST-CONTROLS.json": { + "bytes": 11322, + "matches_frozen_review": true, + "mode": 436, + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "outputs/h25-data-handling-20261028/areas/serialization/SOURCE-READINESS-v3.json": { + "bytes": 773, + "matches_frozen_review": true, + "mode": 436, + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "outputs/h25-data-handling-20261028/areas/serialization/bounded_serialization.py": { + "bytes": 23560, + "matches_frozen_review": true, + "mode": 436, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "outputs/h25-data-handling-20261028/areas/serialization/serialization_controls.py": { + "bytes": 23684, + "matches_frozen_review": true, + "mode": 436, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "approved_review": { + "path": "outputs/h25-data-handling-20261028/review/serialization-v3-source/REVIEW.json", + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + "consumer_status": "AWAITING_CONCRETE_AUTHORED_CONSUMER", + "created_utc": "2026-10-31T04:24:46.761774+00:00", + "execution_admission": false, + "expected_case_count_per_mode": 70, + "expected_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" + ], + "reference_source": { + "outputs/h25-bookkeeping-swarm-20261028/stages/v4/baseline/engine/compare_side_verifier.py": { + "bytes": 10571, + "excerpts": { + "EXPECTED": { + "end_line": 32, + "sha256": "52eaf7b805f3d967123d1323c45412c8acaa928b857f24227969fea139142069", + "source": "EXPECTED = {\n \"result_sha256\": \"342e99212b12e518902ae9598613f5484113bacee8747c27a13b58a4b1d3986c\",\n \"exact_witness_sha256\": \"4b170c1dbfc33c7cb141a2284c6fd69eac7b6d100971d3e9ee625502b5893f82\",\n \"rank_trace_sha256\": \"85006ca332bbc57c2ba9fd06f61a0281d4cee600c9f3b449342379bf2aedec8f\",\n \"rank_call_count\": 59959,\n \"rank_distinct_matrix_count\": 252,\n}", + "start_line": 26 + }, + "write_scientific": { + "end_line": 93, + "sha256": "d040618ae2b678adb4a03bb9145afb32b69c482a5cc363ef9d233eca540f4910", + "source": "def write_scientific(output, result, witness, rank_calls):\n encoded_result = canonical(result)\n encoded_witness = canonical(witness)\n encoded_trace = canonical(rank_calls)\n receipt = {\n \"result_sha256\": hashlib.sha256(encoded_result).hexdigest(),\n \"exact_witness_sha256\": hashlib.sha256(encoded_witness).hexdigest(),\n \"rank_trace_sha256\": hashlib.sha256(encoded_trace).hexdigest(),\n \"rank_call_count\": len(rank_calls),\n \"rank_distinct_matrix_count\": len({rows for rows, _ in rank_calls}),\n }\n require(receipt == EXPECTED, \"Complete output, ordered witness, or rank trace changed from the frozen profile\")\n # Same exact bytes and serialization work in both arms; file hashes omit\n # a trailing newline exactly as the existing profile's digest did.\n (output / \"result.json\").write_bytes(encoded_result)\n (output / \"witness.json\").write_bytes(encoded_witness)\n (output / \"rank-trace.json\").write_bytes(encoded_trace)\n receipt[\"serialized_bytes\"] = {\"result\": len(encoded_result), \"witness\": len(encoded_witness),\n \"rank_trace\": len(encoded_trace)}\n return receipt", + "start_line": 74 + } + }, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "outputs/h25-bookkeeping-swarm-20261028/stages/v4/baseline/engine/native_backend.py": { + "bytes": 20334, + "excerpts": { + "_RUNTIME_ERROR": { + "end_line": 37, + "sha256": "403a516bd3a4e140cca0461b31a66f281a0b822392321074fd60bb42d10b2f8e", + "source": "_RUNTIME_ERROR = RuntimeError", + "start_line": 37 + }, + "require": { + "end_line": 55, + "sha256": "28534588573dfd8f15510cfcc9096f54cda0c01a1c9146c9202174f5ed3f25e4", + "source": "def require(condition, message):\n if not condition:\n raise _RUNTIME_ERROR(message)", + "start_line": 53 + } + }, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "outputs/h25-bookkeeping-swarm-20261028/stages/v4/baseline/engine/profile_side_verifier.py": { + "bytes": 8959, + "excerpts": { + "canonical": { + "end_line": 37, + "sha256": "1930dd916a206a43cb914307033d3ed1d39c7f2c86491b89dd137fdc77ef54b0", + "source": "def canonical(value):\n return json.dumps(value, sort_keys=True, separators=(\",\", \":\"), ensure_ascii=True).encode(\"ascii\")", + "start_line": 36 + } + }, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + } + }, + "review_method": "Metadata hashing and AST source extraction only; no target imports/execution/tests/science", + "schema": "serializer-independent-source-closure-v1", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/README.md b/research/h25-bounded-serializer/validation/README.md new file mode 100644 index 0000000000..647f301ebc --- /dev/null +++ b/research/h25-bounded-serializer/validation/README.md @@ -0,0 +1,9 @@ +# Retained finite validation + +These are verbatim retained evidence from five one-use operations: the first pre-import STOP, its single independently reviewed repair, then 70 normal controls, 70 optimized controls, one baseline consumer and one candidate consumer. Read reviews/PUBLIC-OUTCOME-v2.md for the independently accepted current disposition. F5 and F6 pass; F7 remains partial and no performance gain is demonstrated. + +Each *-raw.json stores every regular retained file under exactly one original run root as a UTF-8 string, original relative path, byte length and SHA256. Encoding each string as UTF-8 recovers the exact original bytes, including empty files. This representation avoids hundreds of separate tiny files while retaining all raw evidence; no target decoder or scientific helper was run to prepare it. Original absolute paths remain historical provenance. No previous protected run tree was read. + +The execution source, source/stage manifests, guarded command proposals, admissions, ledgers, GNU time output, runtime custody evidence and failure/review history are preserved. Component source bytes are in ../component. Source references and manifests retain their original local paths, so replay on another host requires a newly reviewed path mapping, runtime pin inventory, immutable stage and resource admission. These historical runtime pins do not attest another machine. Do not run a copied command with stale absolute paths. Git does not preserve 0444/0555 stage modes. + +The reference/candidate artifact pair totals 9417 bytes. It is a finite fixture, not a representative complete H25 witness. No hosted executable replay hook is added. Hosted planning success is separate from these local retained results. Preparation, independent validation/readback and final metadata-publication physical costs remain OPEN_NOT_ZERO. Policy charges are not a measured complete physical total. No historical timing gap was removed. diff --git a/research/h25-bounded-serializer/validation/RUNTIME-PINS-v3.json b/research/h25-bounded-serializer/validation/RUNTIME-PINS-v3.json new file mode 100644 index 0000000000..0a5932ca34 --- /dev/null +++ b/research/h25-bounded-serializer/validation/RUNTIME-PINS-v3.json @@ -0,0 +1,466 @@ +{ + "assumptions": [ + "Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.", + "File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.", + "Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.", + "Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.", + "Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.", + "Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption." + ], + "created_utc": "2026-10-31T04:40:08.521435+00:00", + "environment": { + "LC_ALL": "C.UTF-8", + "PYTHONDONTWRITEBYTECODE": "1", + "PYTHONHASHSEED": "0", + "PYTHONNOUSERSITE": "1", + "PYTHONSAFEPATH": "1", + "TZ": "UTC" + }, + "executable_realpath": "/usr/bin/python3.12", + "files": { + "/etc/python3.12/sitecustomize.py": { + "bytes": 155, + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e" + }, + "/usr/bin/python3.12": { + "bytes": 8020928, + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f" + }, + "/usr/lib/python3.12/__future__.py": { + "bytes": 5218, + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c" + }, + "/usr/lib/python3.12/_collections_abc.py": { + "bytes": 32082, + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6" + }, + "/usr/lib/python3.12/_compression.py": { + "bytes": 5681, + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981" + }, + "/usr/lib/python3.12/_sitebuiltins.py": { + "bytes": 3128, + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc" + }, + "/usr/lib/python3.12/_weakrefset.py": { + "bytes": 5893, + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac" + }, + "/usr/lib/python3.12/abc.py": { + "bytes": 6538, + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287" + }, + "/usr/lib/python3.12/argparse.py": { + "bytes": 101750, + "sha256": "29395feb61bc376ca4ff9d44069af8d914ec2a1f25a4bd7978f6e2afef5bc07f" + }, + "/usr/lib/python3.12/bisect.py": { + "bytes": 3423, + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999" + }, + "/usr/lib/python3.12/bz2.py": { + "bytes": 11847, + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330" + }, + "/usr/lib/python3.12/codecs.py": { + "bytes": 36870, + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785" + }, + "/usr/lib/python3.12/collections/__init__.py": { + "bytes": 52378, + "sha256": "0af967cd58036507b3d0fbc33b7a996c61dbb52a94b0b738c8bef12cd4cc7dd4" + }, + "/usr/lib/python3.12/collections/abc.py": { + "bytes": 119, + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10" + }, + "/usr/lib/python3.12/contextlib.py": { + "bytes": 27637, + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6" + }, + "/usr/lib/python3.12/copy.py": { + "bytes": 8412, + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab" + }, + "/usr/lib/python3.12/copyreg.py": { + "bytes": 7614, + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9" + }, + "/usr/lib/python3.12/datetime.py": { + "bytes": 268, + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238" + }, + "/usr/lib/python3.12/encodings/__init__.py": { + "bytes": 5884, + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8" + }, + "/usr/lib/python3.12/encodings/aliases.py": { + "bytes": 15677, + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2" + }, + "/usr/lib/python3.12/encodings/utf_8.py": { + "bytes": 1005, + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d" + }, + "/usr/lib/python3.12/enum.py": { + "bytes": 81636, + "sha256": "c8ead615c159598370295649eb296819ad4b40d50b200c4fec2d4269bf7af9ae" + }, + "/usr/lib/python3.12/fnmatch.py": { + "bytes": 5999, + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc" + }, + "/usr/lib/python3.12/functools.py": { + "bytes": 38126, + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033" + }, + "/usr/lib/python3.12/genericpath.py": { + "bytes": 5572, + "sha256": "2b0b35d2206778af4081cf81dd9b513876e72c35a55bec941402e1fa62b1f1aa" + }, + "/usr/lib/python3.12/gettext.py": { + "bytes": 21747, + "sha256": "1cc6fd33bdce3bb29c0c37ec9a2f5bf15a315e9776b329247e6675c028a8af39" + }, + "/usr/lib/python3.12/hashlib.py": { + "bytes": 9349, + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab" + }, + "/usr/lib/python3.12/importlib/__init__.py": { + "bytes": 4774, + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730" + }, + "/usr/lib/python3.12/importlib/_abc.py": { + "bytes": 1354, + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8" + }, + "/usr/lib/python3.12/importlib/_bootstrap.py": { + "bytes": 57056, + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed" + }, + "/usr/lib/python3.12/importlib/_bootstrap_external.py": { + "bytes": 69197, + "sha256": "97c6211750d63067712ad2cd74d50be33337f1fb1cd2c769022ced9b401edd92" + }, + "/usr/lib/python3.12/importlib/machinery.py": { + "bytes": 880, + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede" + }, + "/usr/lib/python3.12/importlib/util.py": { + "bytes": 10840, + "sha256": "ca54e6458dbe521d591e5b8d9bb651ef929bfae946706c98470cdd569041a64f" + }, + "/usr/lib/python3.12/io.py": { + "bytes": 3582, + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822" + }, + "/usr/lib/python3.12/ipaddress.py": { + "bytes": 78294, + "sha256": "cc9831e239bd81c1480a12733bded744002d93815fd0d083c77aea348c956e67" + }, + "/usr/lib/python3.12/json/__init__.py": { + "bytes": 14020, + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5" + }, + "/usr/lib/python3.12/json/decoder.py": { + "bytes": 12473, + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b" + }, + "/usr/lib/python3.12/json/encoder.py": { + "bytes": 16070, + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869" + }, + "/usr/lib/python3.12/json/scanner.py": { + "bytes": 2425, + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08" + }, + "/usr/lib/python3.12/keyword.py": { + "bytes": 1073, + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b" + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "bytes": 32112, + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76" + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "bytes": 64368, + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe" + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "bytes": 48952, + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3" + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "bytes": 49256, + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7" + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "bytes": 19432, + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907" + }, + "/usr/lib/python3.12/locale.py": { + "bytes": 78562, + "sha256": "d1134b7212bad37b7b81339061dc37a19a194aa183ec2cb60412cf365993b151" + }, + "/usr/lib/python3.12/lzma.py": { + "bytes": 13277, + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e" + }, + "/usr/lib/python3.12/ntpath.py": { + "bytes": 30027, + "sha256": "c4dd79bf103677daaad873952b89fc1f973425e7b250006cc35af4c164181da8" + }, + "/usr/lib/python3.12/operator.py": { + "bytes": 10965, + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a" + }, + "/usr/lib/python3.12/os.py": { + "bytes": 39786, + "sha256": "316d1b7307fd851bded3423c9d437e0a383c725d993f0fcff2e8b749fe560b62" + }, + "/usr/lib/python3.12/pathlib.py": { + "bytes": 51153, + "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d" + }, + "/usr/lib/python3.12/platform.py": { + "bytes": 43331, + "sha256": "ed0defe8ff7c116710493ffd099b566d3de686ab1b431a3d5401056798e59341" + }, + "/usr/lib/python3.12/posixpath.py": { + "bytes": 17623, + "sha256": "c443d7b8afad1717e7060ce49b3e04423058de56cd4246ee6bcc1ac962eb5c2b" + }, + "/usr/lib/python3.12/random.py": { + "bytes": 34683, + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425" + }, + "/usr/lib/python3.12/re/__init__.py": { + "bytes": 16315, + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b" + }, + "/usr/lib/python3.12/re/_casefix.py": { + "bytes": 5446, + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40" + }, + "/usr/lib/python3.12/re/_compiler.py": { + "bytes": 26089, + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a" + }, + "/usr/lib/python3.12/re/_constants.py": { + "bytes": 5930, + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375" + }, + "/usr/lib/python3.12/re/_parser.py": { + "bytes": 41201, + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840" + }, + "/usr/lib/python3.12/reprlib.py": { + "bytes": 6569, + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015" + }, + "/usr/lib/python3.12/selectors.py": { + "bytes": 19671, + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385" + }, + "/usr/lib/python3.12/shutil.py": { + "bytes": 58120, + "sha256": "819e518cb7a539d09b2526138015541b34d2646afb9c2f6ae4ffd476d6a0fcf4" + }, + "/usr/lib/python3.12/signal.py": { + "bytes": 2495, + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a" + }, + "/usr/lib/python3.12/site.py": { + "bytes": 23903, + "sha256": "619436355cbe91c3b29681ab486ee63f5f2e0a7d6274dfae747bdb94e60bca55" + }, + "/usr/lib/python3.12/stat.py": { + "bytes": 5485, + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77" + }, + "/usr/lib/python3.12/subprocess.py": { + "bytes": 88725, + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9" + }, + "/usr/lib/python3.12/tempfile.py": { + "bytes": 37334, + "sha256": "8c8033ed1426ace79e07a6608887d2a1694d817d63d61b04c3d59339f24b4269" + }, + "/usr/lib/python3.12/threading.py": { + "bytes": 60123, + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b" + }, + "/usr/lib/python3.12/types.py": { + "bytes": 10993, + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405" + }, + "/usr/lib/python3.12/urllib/__init__.py": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "/usr/lib/python3.12/urllib/parse.py": { + "bytes": 45591, + "sha256": "a67b5694763137dbac085adbf0c22821d435ec8ca22d3bd3786d2c9f4ee748d5" + }, + "/usr/lib/python3.12/warnings.py": { + "bytes": 21760, + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49" + }, + "/usr/lib/python3.12/weakref.py": { + "bytes": 21513, + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c" + }, + "/usr/lib/python3.12/zipimport.py": { + "bytes": 28132, + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0" + }, + "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py": { + "bytes": 6299, + "sha256": "46849a60a7cc85189cf6b5ac62b3f135004862ce6a96540a81c95ef6fbc4dc3e" + }, + "/usr/lib/python3/dist-packages/apport_python_hook.py": { + "bytes": 8695, + "sha256": "2aac4de740babcc6038483cccc7fa71f7f06405da9b9d102aafe8ac55f509c4b" + }, + "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py": { + "bytes": 122, + "sha256": "c38b82e5f241e83edbbe9bcfdcb8747f11071b32fbc8b7c950e38260a0059edb" + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "bytes": 236616, + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da" + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "bytes": 78944, + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1" + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "bytes": 2129424, + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf" + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "bytes": 5309400, + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a" + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "bytes": 186624, + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d" + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "bytes": 202904, + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d" + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "bytes": 952616, + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0" + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "bytes": 113000, + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242" + } + }, + "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", + "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.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", + "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", + "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" + }, + "observed_file_backed_libraries": [ + "/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" + ], + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/control/RUNTIME-PINS-v2.json", + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c" + }, + "python_version": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "repair": "Add omitted system-site hook whose resolved source path is /etc/python3.12/sitecustomize.py; retain failed v2 inventory and all source/control bytes.", + "schema": "serializer-finite-runtime-pins-v1" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/INVENTORY-PROPOSED.json b/research/h25-bounded-serializer/validation/execution-source-v1/INVENTORY-PROPOSED.json new file mode 100644 index 0000000000..81a802949e --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/INVENTORY-PROPOSED.json @@ -0,0 +1,66 @@ +{ + "author_execution": false, + "forbidden_inherited_environment": [ + "PYTHONPATH", + "PYTHONOPTIMIZE", + "PYTHONINSPECT", + "PYTHONSTARTUP", + "PYTHONPYCACHEPREFIX" + ], + "guard_unchanged": true, + "new_budget": false, + "operations": [ + { + "cases": 70, + "job": "serializer-controls-normal", + "mode": "controls", + "optimization": 0 + }, + { + "cases": 70, + "job": "serializer-controls-O", + "mode": "controls", + "optimization": 1 + }, + { + "job": "serializer-baseline-2048", + "mode": "baseline", + "optimization": 0, + "support_rows": 2048 + }, + { + "job": "serializer-candidate-2048", + "mode": "candidate", + "optimization": 0, + "support_rows": 2048 + } + ], + "proposed_environment": { + "LC_ALL": "C.UTF-8", + "PYTHONDONTWRITEBYTECODE": "1", + "PYTHONHASHSEED": "0", + "PYTHONNOUSERSITE": "1", + "PYTHONSAFEPATH": "1", + "TZ": "UTC" + }, + "runtime_manifest": { + "file_count": 84, + "original": "control/RUNTIME-PINS-v2.json", + "schema": "serializer-finite-runtime-pins-v1", + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c", + "stage_copy": "RUNTIME-PINS.json" + }, + "runtime_origin_policy": "Every loaded file-backed module must resolve to its parent module_paths entry, exact local component source, or the actual adapter __main__ path. Builtin/frozen and cached-bytecode assumptions remain parent finite-host conditions.", + "runtime_precondition": "Actual parent supplied source/binary pins and exact supported finite-host assumptions reviewed before stage admission; no original fullH25 custody claim", + "schema": "h25-serializer-finite-execution-source-inventory-v1", + "serializer_manifest_sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e", + "stage_layout": { + "JOBS.json": "Exactly4 fixed operations; all finite_only; only controls-O optimized", + "RUNTIME-PINS.json": "Parent trusted current interpreter/stdlib/extension/linked-library/environment manifest; no runtime discovery by this author", + "RUNTIME-PINS.sha256": "Parent independently supplied expected manifest hash, itself authenticated by parent immutable STAGE metadata", + "STAGE.json": "Parent assembles exact files/modes plus unchanged runner_sha256; author does not assemble/admit stage", + "integration/full_driver.py": "This owned tiny adapter; exact unchanged guarded runner CLI interface", + "package/": "Parent copies byte-exact frozen serializer package with all21 payload files plus SOURCE-PINS.json" + }, + "status": "SOURCE_AUTHORED_PENDING_INDEPENDENT_REVIEW_NO_EXECUTION" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/JOBS.json b/research/h25-bounded-serializer/validation/execution-source-v1/JOBS.json new file mode 100644 index 0000000000..6cb5d64158 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/JOBS.json @@ -0,0 +1,22 @@ +{ + "serializer-controls-normal": { + "lanes": "serializer-controls", + "finite_only": true, + "optimized": false + }, + "serializer-controls-O": { + "lanes": "serializer-controls", + "finite_only": true, + "optimized": true + }, + "serializer-baseline-2048": { + "lanes": "serializer-baseline-2048", + "finite_only": true, + "optimized": false + }, + "serializer-candidate-2048": { + "lanes": "serializer-candidate-2048", + "finite_only": true, + "optimized": false + } +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/README.md b/research/h25-bounded-serializer/validation/execution-source-v1/README.md new file mode 100644 index 0000000000..3f1fcda36d --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/README.md @@ -0,0 +1,13 @@ +# Fixed finite serializer execution adapter: source only + +This adapter targets the unchanged `outputs/h25-stable-packages-publication-20261031/validation/run_guarded.py` interface. The parent assembles a new immutable stage containing these sources and the entire exact frozen serializer package at `package/`. `JOBS.json` declares exactly four operations: 70 controls normally, 70 controls with -O, baseline 2048 rows normally, and candidate 2048 rows normally. All jobs are finite-only. Baseline/candidate cannot run optimized; no complete scientific lane exists. + +The adapter first authenticates the independently supplied `RUNTIME-PINS.sha256` anchor through the parent's immutable STAGE custody, checks the exact runtime manifest hash and metadata, checks the frozen serializer manifest against embedded SHA5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e, and hashes all 21 payload files and all 84 parent runtime files. All source files are bounded-read hashed as regular resolved files with before/after descriptor/path identity checks. No target component is imported before successful checks. It then adds only the authenticated package path and invokes the actual frozen `component_consumer.run_component`. + +After return or a primary exception, all custody checks run again. Every loaded file-backed module must have its actual origin in the parent module map, one of the four exact package modules, or the actual adapter path for __main__. A primary exception is re-raised if post-check or boundary-record writing also fails. The additive `adapter-boundary.json` records actual Python version, executable, optimization, no-user-site/safe-path/bytecode flags, six environment values, custody results, module origins and primary/secondary error types. Failure files are retained. Target termination/kill before finally can prevent a post-check or receipt; parent must reject an incomplete operation. + +`RUNTIME-PINS.json` is an exact copy of parent control/RUNTIME-PINS-v2.json, SHA841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c. V1 was preserved; v2 adds the __future__ source dependency and explicit supported system-site/cached-bytecode assumptions. This is a trusted finite local CPython3.12/Linux host contract with no hostile concurrent module/loader/file mutation. Recorded interpreter/source/extension/library hashes and module origins do not establish arbitrary host/process-memory attestation or original complete H25 custody. The parent separately authenticates its runner, launcher, manifest anchors and complete stage before launch and after exit. + +The existing guard remains byte unchanged, including its600/2400 phase contract. The parent owns existing-budget accounting, exact launch/timeout cleanup and resource admission. Source-only preparation does not reset or create any allowance. Parent proposed four outer reservations of122.01seconds each, total488.04seconds, plus historical63.770533479seconds =551.810533479seconds < existinginitial600. Actual charged results, failures, metadata costs and outer cleanup still require parent reconciliation. Timeout behavior, cleanup and resource fit have not been exercised by this source author. + +The complete per-operation bill includes startup/imports; two full runtime and package read/hash traversals; manifest parsing; file inventories, metadata and module-origin checks; the frozen consumer's complete control/fixture/setup/serialization/readback work; adapter-boundary serialization/write; stdout, close and exit; outer guard/launcher and independent validation. Runtime-pin materialization, this source preparation and final metadata publication physical costs remain outside complete measured closure and are not zero. No actual execution, measurement, source self-approval or performance claim exists here. diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/RUNTIME-PINS.json b/research/h25-bounded-serializer/validation/execution-source-v1/RUNTIME-PINS.json new file mode 100644 index 0000000000..63522f8f96 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/RUNTIME-PINS.json @@ -0,0 +1,460 @@ +{ + "assumptions": [ + "Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.", + "File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.", + "Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.", + "Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.", + "Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.", + "Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption." + ], + "created_utc": "2026-10-31T04:32:57.738851+00:00", + "environment": { + "LC_ALL": "C.UTF-8", + "PYTHONDONTWRITEBYTECODE": "1", + "PYTHONHASHSEED": "0", + "PYTHONNOUSERSITE": "1", + "PYTHONSAFEPATH": "1", + "TZ": "UTC" + }, + "executable_realpath": "/usr/bin/python3.12", + "files": { + "/usr/bin/python3.12": { + "bytes": 8020928, + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f" + }, + "/usr/lib/python3.12/__future__.py": { + "bytes": 5218, + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c" + }, + "/usr/lib/python3.12/_collections_abc.py": { + "bytes": 32082, + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6" + }, + "/usr/lib/python3.12/_compression.py": { + "bytes": 5681, + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981" + }, + "/usr/lib/python3.12/_sitebuiltins.py": { + "bytes": 3128, + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc" + }, + "/usr/lib/python3.12/_weakrefset.py": { + "bytes": 5893, + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac" + }, + "/usr/lib/python3.12/abc.py": { + "bytes": 6538, + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287" + }, + "/usr/lib/python3.12/argparse.py": { + "bytes": 101750, + "sha256": "29395feb61bc376ca4ff9d44069af8d914ec2a1f25a4bd7978f6e2afef5bc07f" + }, + "/usr/lib/python3.12/bisect.py": { + "bytes": 3423, + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999" + }, + "/usr/lib/python3.12/bz2.py": { + "bytes": 11847, + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330" + }, + "/usr/lib/python3.12/codecs.py": { + "bytes": 36870, + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785" + }, + "/usr/lib/python3.12/collections/__init__.py": { + "bytes": 52378, + "sha256": "0af967cd58036507b3d0fbc33b7a996c61dbb52a94b0b738c8bef12cd4cc7dd4" + }, + "/usr/lib/python3.12/collections/abc.py": { + "bytes": 119, + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10" + }, + "/usr/lib/python3.12/contextlib.py": { + "bytes": 27637, + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6" + }, + "/usr/lib/python3.12/copy.py": { + "bytes": 8412, + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab" + }, + "/usr/lib/python3.12/copyreg.py": { + "bytes": 7614, + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9" + }, + "/usr/lib/python3.12/datetime.py": { + "bytes": 268, + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238" + }, + "/usr/lib/python3.12/encodings/__init__.py": { + "bytes": 5884, + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8" + }, + "/usr/lib/python3.12/encodings/aliases.py": { + "bytes": 15677, + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2" + }, + "/usr/lib/python3.12/encodings/utf_8.py": { + "bytes": 1005, + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d" + }, + "/usr/lib/python3.12/enum.py": { + "bytes": 81636, + "sha256": "c8ead615c159598370295649eb296819ad4b40d50b200c4fec2d4269bf7af9ae" + }, + "/usr/lib/python3.12/fnmatch.py": { + "bytes": 5999, + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc" + }, + "/usr/lib/python3.12/functools.py": { + "bytes": 38126, + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033" + }, + "/usr/lib/python3.12/genericpath.py": { + "bytes": 5572, + "sha256": "2b0b35d2206778af4081cf81dd9b513876e72c35a55bec941402e1fa62b1f1aa" + }, + "/usr/lib/python3.12/gettext.py": { + "bytes": 21747, + "sha256": "1cc6fd33bdce3bb29c0c37ec9a2f5bf15a315e9776b329247e6675c028a8af39" + }, + "/usr/lib/python3.12/hashlib.py": { + "bytes": 9349, + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab" + }, + "/usr/lib/python3.12/importlib/__init__.py": { + "bytes": 4774, + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730" + }, + "/usr/lib/python3.12/importlib/_abc.py": { + "bytes": 1354, + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8" + }, + "/usr/lib/python3.12/importlib/_bootstrap.py": { + "bytes": 57056, + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed" + }, + "/usr/lib/python3.12/importlib/_bootstrap_external.py": { + "bytes": 69197, + "sha256": "97c6211750d63067712ad2cd74d50be33337f1fb1cd2c769022ced9b401edd92" + }, + "/usr/lib/python3.12/importlib/machinery.py": { + "bytes": 880, + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede" + }, + "/usr/lib/python3.12/importlib/util.py": { + "bytes": 10840, + "sha256": "ca54e6458dbe521d591e5b8d9bb651ef929bfae946706c98470cdd569041a64f" + }, + "/usr/lib/python3.12/io.py": { + "bytes": 3582, + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822" + }, + "/usr/lib/python3.12/ipaddress.py": { + "bytes": 78294, + "sha256": "cc9831e239bd81c1480a12733bded744002d93815fd0d083c77aea348c956e67" + }, + "/usr/lib/python3.12/json/__init__.py": { + "bytes": 14020, + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5" + }, + "/usr/lib/python3.12/json/decoder.py": { + "bytes": 12473, + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b" + }, + "/usr/lib/python3.12/json/encoder.py": { + "bytes": 16070, + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869" + }, + "/usr/lib/python3.12/json/scanner.py": { + "bytes": 2425, + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08" + }, + "/usr/lib/python3.12/keyword.py": { + "bytes": 1073, + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b" + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "bytes": 32112, + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76" + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "bytes": 64368, + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe" + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "bytes": 48952, + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3" + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "bytes": 49256, + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7" + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "bytes": 19432, + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907" + }, + "/usr/lib/python3.12/locale.py": { + "bytes": 78562, + "sha256": "d1134b7212bad37b7b81339061dc37a19a194aa183ec2cb60412cf365993b151" + }, + "/usr/lib/python3.12/lzma.py": { + "bytes": 13277, + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e" + }, + "/usr/lib/python3.12/ntpath.py": { + "bytes": 30027, + "sha256": "c4dd79bf103677daaad873952b89fc1f973425e7b250006cc35af4c164181da8" + }, + "/usr/lib/python3.12/operator.py": { + "bytes": 10965, + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a" + }, + "/usr/lib/python3.12/os.py": { + "bytes": 39786, + "sha256": "316d1b7307fd851bded3423c9d437e0a383c725d993f0fcff2e8b749fe560b62" + }, + "/usr/lib/python3.12/pathlib.py": { + "bytes": 51153, + "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d" + }, + "/usr/lib/python3.12/platform.py": { + "bytes": 43331, + "sha256": "ed0defe8ff7c116710493ffd099b566d3de686ab1b431a3d5401056798e59341" + }, + "/usr/lib/python3.12/posixpath.py": { + "bytes": 17623, + "sha256": "c443d7b8afad1717e7060ce49b3e04423058de56cd4246ee6bcc1ac962eb5c2b" + }, + "/usr/lib/python3.12/random.py": { + "bytes": 34683, + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425" + }, + "/usr/lib/python3.12/re/__init__.py": { + "bytes": 16315, + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b" + }, + "/usr/lib/python3.12/re/_casefix.py": { + "bytes": 5446, + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40" + }, + "/usr/lib/python3.12/re/_compiler.py": { + "bytes": 26089, + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a" + }, + "/usr/lib/python3.12/re/_constants.py": { + "bytes": 5930, + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375" + }, + "/usr/lib/python3.12/re/_parser.py": { + "bytes": 41201, + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840" + }, + "/usr/lib/python3.12/reprlib.py": { + "bytes": 6569, + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015" + }, + "/usr/lib/python3.12/selectors.py": { + "bytes": 19671, + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385" + }, + "/usr/lib/python3.12/shutil.py": { + "bytes": 58120, + "sha256": "819e518cb7a539d09b2526138015541b34d2646afb9c2f6ae4ffd476d6a0fcf4" + }, + "/usr/lib/python3.12/signal.py": { + "bytes": 2495, + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a" + }, + "/usr/lib/python3.12/site.py": { + "bytes": 23903, + "sha256": "619436355cbe91c3b29681ab486ee63f5f2e0a7d6274dfae747bdb94e60bca55" + }, + "/usr/lib/python3.12/stat.py": { + "bytes": 5485, + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77" + }, + "/usr/lib/python3.12/subprocess.py": { + "bytes": 88725, + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9" + }, + "/usr/lib/python3.12/tempfile.py": { + "bytes": 37334, + "sha256": "8c8033ed1426ace79e07a6608887d2a1694d817d63d61b04c3d59339f24b4269" + }, + "/usr/lib/python3.12/threading.py": { + "bytes": 60123, + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b" + }, + "/usr/lib/python3.12/types.py": { + "bytes": 10993, + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405" + }, + "/usr/lib/python3.12/urllib/__init__.py": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "/usr/lib/python3.12/urllib/parse.py": { + "bytes": 45591, + "sha256": "a67b5694763137dbac085adbf0c22821d435ec8ca22d3bd3786d2c9f4ee748d5" + }, + "/usr/lib/python3.12/warnings.py": { + "bytes": 21760, + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49" + }, + "/usr/lib/python3.12/weakref.py": { + "bytes": 21513, + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c" + }, + "/usr/lib/python3.12/zipimport.py": { + "bytes": 28132, + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0" + }, + "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py": { + "bytes": 6299, + "sha256": "46849a60a7cc85189cf6b5ac62b3f135004862ce6a96540a81c95ef6fbc4dc3e" + }, + "/usr/lib/python3/dist-packages/apport_python_hook.py": { + "bytes": 8695, + "sha256": "2aac4de740babcc6038483cccc7fa71f7f06405da9b9d102aafe8ac55f509c4b" + }, + "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py": { + "bytes": 122, + "sha256": "c38b82e5f241e83edbbe9bcfdcb8747f11071b32fbc8b7c950e38260a0059edb" + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "bytes": 236616, + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da" + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "bytes": 78944, + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1" + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "bytes": 2129424, + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf" + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "bytes": 5309400, + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a" + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "bytes": 186624, + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d" + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "bytes": 202904, + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d" + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "bytes": 952616, + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0" + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "bytes": 113000, + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242" + } + }, + "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", + "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.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", + "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", + "stat": "/usr/lib/python3.12/stat.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" + }, + "observed_file_backed_libraries": [ + "/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" + ], + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/control/RUNTIME-PINS-v1.json", + "sha256": "88e9f26c0946f88a768aa7660d85bdcf3a4a5864ed85a74979233351151251d8" + }, + "python_version": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "schema": "serializer-finite-runtime-pins-v1" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/RUNTIME-PINS.sha256 b/research/h25-bounded-serializer/validation/execution-source-v1/RUNTIME-PINS.sha256 new file mode 100644 index 0000000000..a58b2aa726 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/RUNTIME-PINS.sha256 @@ -0,0 +1 @@ +841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/SOURCE-PINS.json b/research/h25-bounded-serializer/validation/execution-source-v1/SOURCE-PINS.json new file mode 100644 index 0000000000..0e9d55551e --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/SOURCE-PINS.json @@ -0,0 +1,37 @@ +{ + "execution_admission": false, + "files": { + "INVENTORY-PROPOSED.json": { + "bytes": 2665, + "mode": 292, + "sha256": "963f076fe7167df374cf689c7cf8b0ed4b11031c3eb7f2f3f23c9b9313b4785b" + }, + "JOBS.json": { + "bytes": 497, + "mode": 292, + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + "README.md": { + "bytes": 3823, + "mode": 292, + "sha256": "b08ce8ec929e8dc8289b71fd80351476e74305bf82ffbdae9e51f4e1ea18445e" + }, + "RUNTIME-PINS.json": { + "bytes": 20275, + "mode": 292, + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c" + }, + "RUNTIME-PINS.sha256": { + "bytes": 65, + "mode": 292, + "sha256": "3f19eff68ec00a26632c5049950387ca94d5124dd11807f7fa0c81ee91abfc71" + }, + "integration/full_driver.py": { + "bytes": 8418, + "mode": 292, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + } + }, + "schema": "serializer-fixed-execution-source-pins-v1", + "status": "SOURCE_ONLY_PENDING_INDEPENDENT_REVIEW" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v1/integration/full_driver.py b/research/h25-bounded-serializer/validation/execution-source-v1/integration/full_driver.py new file mode 100644 index 0000000000..c96966772f --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v1/integration/full_driver.py @@ -0,0 +1,177 @@ +"""Four fixed finite serializer operations under the unchanged parent guard. + +Trusted finite host, no hostile concurrent mutation. This authenticates declared +files/origins, not arbitrary process memory or original complete H25 custody. +""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import stat +import sys + +STAGE = Path(__file__).resolve().parents[1] +PACKAGE = STAGE / "package" +PACKAGE_SHA256 = "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" +LOCAL = ("component_consumer", "reference", "bounded_serialization", "serialization_controls") +ENV = {"PYTHONHASHSEED": "0", "LC_ALL": "C.UTF-8", "TZ": "UTC", + "PYTHONDONTWRITEBYTECODE": "1", "PYTHONNOUSERSITE": "1", "PYTHONSAFEPATH": "1"} +LANES = {"serializer-controls": "controls", "serializer-baseline-2048": "baseline", + "serializer-candidate-2048": "candidate"} + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def small(path): + with path.open("rb") as stream: + raw = stream.read(1048577) + need(len(raw) <= 1048576, "Custody metadata exceeded 1MiB") + return raw + + +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 file_pin(path): + need(path.is_absolute() and path.resolve() == path, "Pin path must be resolved absolute") + before = path.lstat() + 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()) + need(stat.S_ISREG(opened.st_mode), "Pin is not a regular file") + count, hasher = 0, hashlib.sha256() + while count < opened.st_size: + raw = stream.read(min(1048576, opened.st_size - count)) + need(bool(raw), "Pinned file ended early") + hasher.update(raw) + count += len(raw) + after = os.fstat(stream.fileno()) + need(identity(before) == identity(opened) == identity(after) == identity(path.lstat()), + "Pinned file changed while hashing") + return {"bytes": count, "sha256": hasher.hexdigest()} + + +def origins(runtime): + observed = {} + for name, module in tuple(sys.modules.items()): + filename = getattr(module, "__file__", None) + if filename is None: + continue + actual = str(Path(filename).resolve()) + if name == "__main__": + expected = str(Path(__file__).resolve()) + elif name in LOCAL: + expected = str(PACKAGE / (name + ".py")) + else: + expected = runtime["module_paths"].get(name) + need(actual == expected, "Unadmitted file-backed module origin: " + name) + observed[name] = actual + return observed + + +def custody(anchor): + need(small(STAGE / "RUNTIME-PINS.sha256") == anchor, "Runtime anchor changed") + expected_runtime = anchor.decode("ascii").strip() + need(len(expected_runtime) == 64 and all(c in "0123456789abcdef" for c in expected_runtime), + "Malformed parent runtime anchor") + runtime_raw = small(STAGE / "RUNTIME-PINS.json") + need(hashlib.sha256(runtime_raw).hexdigest() == expected_runtime, + "Runtime manifest differs from independent parent anchor") + runtime = json.loads(runtime_raw) + need(runtime["schema"] == "serializer-finite-runtime-pins-v1", "Runtime schema differs") + need(runtime["python_version"] == sys.version and + runtime["executable_realpath"] == str(Path(sys.executable).resolve()) == "/usr/bin/python3.12", + "Interpreter differs from parent runtime") + need(runtime["environment"] == ENV and all(os.environ.get(k) == v for k, v in ENV.items()), + "Finite environment differs") + need(not any(name in os.environ for name in + ("PYTHONPATH", "PYTHONOPTIMIZE", "PYTHONINSPECT", "PYTHONSTARTUP", "PYTHONPYCACHEPREFIX")), + "Forbidden Python startup environment") + need(sys.flags.no_user_site == 1 and sys.flags.safe_path and sys.dont_write_bytecode, + "Required finite startup flags absent") + package_raw = small(PACKAGE / "SOURCE-PINS.json") + need(hashlib.sha256(package_raw).hexdigest() == PACKAGE_SHA256, "Serializer manifest changed") + package = json.loads(package_raw) + expected_paths = set(package["files"]) | {"SOURCE-PINS.json"} + actual_paths = set() + for path in PACKAGE.rglob("*"): + need(not path.is_symlink(), "Symlink in frozen serializer") + if path.is_file(): + actual_paths.add(str(path.relative_to(PACKAGE))) + need(actual_paths == expected_paths, "Serializer file inventory changed") + for relative, pin in package["files"].items(): + path = PACKAGE / relative + need(file_pin(path) == {"bytes": pin["bytes"], "sha256": pin["sha256"]} and + oct(stat.S_IMODE(path.stat().st_mode)) == pin["mode_octal"], + "Serializer payload changed: " + relative) + for filename, pin in runtime["files"].items(): + need(file_pin(Path(filename)) == pin, "Runtime file changed: " + filename) + return {"runtime_manifest_sha256": expected_runtime, "runtime_file_count": len(runtime["files"]), + "serializer_manifest_sha256": PACKAGE_SHA256, "serializer_payload_files": len(package["files"]), + "module_origins": origins(runtime), "assumptions": runtime["assumptions"]} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--lanes", choices=tuple(LANES), required=True) + parser.add_argument("--finite-only", action="store_true") + args = parser.parse_args() + need(args.finite_only, "This adapter admits only fixed finite operations") + mode = LANES[args.lanes] + need(sys.flags.optimize in ((0, 1) if mode == "controls" else (0,)), "Undeclared optimization mode") + need(not args.output.exists(), "Refusing earlier adapter evidence") + args.output.mkdir(parents=True) + boundary = {"scope": "Supported finite serializer host only; no full H25 custody/performance claim", + "mode": mode, "fixture_rows": None if mode == "controls" else 2048, + "python_version": sys.version, "executable": sys.executable, + "executable_realpath": str(Path(sys.executable).resolve()), + "optimization": sys.flags.optimize, "no_user_site": sys.flags.no_user_site, + "safe_path": sys.flags.safe_path, "dont_write_bytecode": sys.dont_write_bytecode, + "environment": {key: os.environ.get(key) for key in ENV}, "status": "STARTED"} + primary, post_error, anchor = None, None, None + try: + anchor = small(STAGE / "RUNTIME-PINS.sha256") + boundary["before"] = custody(anchor) + need(not any(name in sys.modules for name in LOCAL), "Component module preloaded") + sys.path.insert(0, str(PACKAGE)) + import component_consumer + need(Path(component_consumer.__file__).resolve() == PACKAGE / "component_consumer.py", + "Actual consumer source differs") + receipt = component_consumer.run_component(mode, args.output / "component", rows=2048) + boundary["component_status"] = receipt["status"] + boundary["status"] = "FINITE_COMPONENT_RETURNED" + except BaseException as error: + primary = error + boundary["status"] = "PRIMARY_ERROR" + boundary["primary_error_type"] = type(error).__name__ + raise + finally: + try: + need(anchor is not None, "Runtime anchor was not obtained") + boundary["after"] = custody(anchor) + except BaseException as error: + post_error = error + boundary["postcheck_error_type"] = type(error).__name__ + if primary is None: + boundary["status"] = "POSTCHECK_ERROR" + try: + (args.output / "adapter-boundary.json").write_text(json.dumps(boundary, sort_keys=True, indent=2) + + "\n", encoding="utf-8") + except BaseException: + if primary is None and post_error is None: + raise + if primary is None and post_error is not None: + raise post_error + print(json.dumps({"status": boundary["status"], "mode": mode, + "optimization": sys.flags.optimize}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/INVENTORY-PROPOSED.json b/research/h25-bounded-serializer/validation/execution-source-v2/INVENTORY-PROPOSED.json new file mode 100644 index 0000000000..9a192a7f59 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/INVENTORY-PROPOSED.json @@ -0,0 +1,67 @@ +{ + "author_execution": false, + "forbidden_inherited_environment": [ + "PYTHONPATH", + "PYTHONOPTIMIZE", + "PYTHONINSPECT", + "PYTHONSTARTUP", + "PYTHONPYCACHEPREFIX" + ], + "guard_unchanged": true, + "new_budget": false, + "operations": [ + { + "cases": 70, + "job": "serializer-controls-normal", + "mode": "controls", + "optimization": 0 + }, + { + "cases": 70, + "job": "serializer-controls-O", + "mode": "controls", + "optimization": 1 + }, + { + "job": "serializer-baseline-2048", + "mode": "baseline", + "optimization": 0, + "support_rows": 2048 + }, + { + "job": "serializer-candidate-2048", + "mode": "candidate", + "optimization": 0, + "support_rows": 2048 + } + ], + "proposed_environment": { + "LC_ALL": "C.UTF-8", + "PYTHONDONTWRITEBYTECODE": "1", + "PYTHONHASHSEED": "0", + "PYTHONNOUSERSITE": "1", + "PYTHONSAFEPATH": "1", + "TZ": "UTC" + }, + "runtime_manifest": { + "file_count": 85, + "original": "control/RUNTIME-PINS-v3.json", + "schema": "serializer-finite-runtime-pins-v1", + "sha256": "972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02", + "stage_copy": "RUNTIME-PINS.json" + }, + "runtime_origin_policy": "Every loaded file-backed module must resolve to its parent module_paths entry, exact local component source, or the actual adapter __main__ path. Builtin/frozen and cached-bytecode assumptions remain parent finite-host conditions.", + "runtime_precondition": "Actual parent supplied source/binary pins and exact supported finite-host assumptions reviewed before stage admission; no original fullH25 custody claim", + "schema": "h25-serializer-finite-execution-source-inventory-v1", + "serializer_manifest_sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e", + "stage_layout": { + "JOBS.json": "Exactly4 fixed operations; all finite_only; only controls-O optimized", + "RUNTIME-PINS.json": "Parent trusted current interpreter/stdlib/extension/linked-library/environment manifest; no runtime discovery by this author", + "RUNTIME-PINS.sha256": "Parent independently supplied expected manifest hash, itself authenticated by parent immutable STAGE metadata", + "STAGE.json": "Parent assembles exact files/modes plus unchanged runner_sha256; author does not assemble/admit stage", + "integration/full_driver.py": "This owned tiny adapter; exact unchanged guarded runner CLI interface", + "package/": "Parent copies byte-exact frozen serializer package with all21 payload files plus SOURCE-PINS.json" + }, + "status": "ONE_SOURCE_REPAIR_AUTHORED_PENDING_NEW_INDEPENDENT_REVIEW_NO_RETRY_ADMISSION", + "supersedes_for_future_stage_only": "execution-source-v1; v1 preserved with its actual failed attempt; parent must assemble distinct serializer-v2 stage and obtain new admission" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/JOBS.json b/research/h25-bounded-serializer/validation/execution-source-v2/JOBS.json new file mode 100644 index 0000000000..6cb5d64158 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/JOBS.json @@ -0,0 +1,22 @@ +{ + "serializer-controls-normal": { + "lanes": "serializer-controls", + "finite_only": true, + "optimized": false + }, + "serializer-controls-O": { + "lanes": "serializer-controls", + "finite_only": true, + "optimized": true + }, + "serializer-baseline-2048": { + "lanes": "serializer-baseline-2048", + "finite_only": true, + "optimized": false + }, + "serializer-candidate-2048": { + "lanes": "serializer-candidate-2048", + "finite_only": true, + "optimized": false + } +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/README.md b/research/h25-bounded-serializer/validation/execution-source-v2/README.md new file mode 100644 index 0000000000..8e7faab9a8 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/README.md @@ -0,0 +1,15 @@ +# Fixed finite serializer execution adapter: source only + +This adapter targets the unchanged `outputs/h25-stable-packages-publication-20261031/validation/run_guarded.py` interface. The parent assembles a new immutable stage containing these sources and the entire exact frozen serializer package at `package/`. `JOBS.json` declares exactly four operations: 70 controls normally, 70 controls with -O, baseline 2048 rows normally, and candidate 2048 rows normally. All jobs are finite-only. Baseline/candidate cannot run optimized; no complete scientific lane exists. + +The adapter first authenticates the independently supplied `RUNTIME-PINS.sha256` anchor through the parent's immutable STAGE custody, checks the exact runtime manifest hash and metadata, checks the frozen serializer manifest against embedded SHA5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e, and hashes all 21 payload files and all 85 parent runtime files. All source files are bounded-read hashed as regular resolved files with before/after descriptor/path identity checks. No target component is imported before successful checks. It then adds only the authenticated package path and invokes the actual frozen `component_consumer.run_component`. + +After return or a primary exception, all custody checks run again. Every loaded file-backed module must have its actual origin in the parent module map, one of the four exact package modules, or the actual adapter path for __main__. A primary exception is re-raised if post-check or boundary-record writing also fails. The additive `adapter-boundary.json` records actual Python version, executable, optimization, no-user-site/safe-path/bytecode flags, six environment values, custody results, module origins and primary/secondary error types. Failure files are retained. Target termination/kill before finally can prevent a post-check or receipt; parent must reject an incomplete operation. + +`RUNTIME-PINS.json` is an exact copy of parent control/RUNTIME-PINS-v3.json, SHA972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02. Runtime v1 and v2 remain preserved. Runtime v3 adds the actual /etc/python3.12/sitecustomize.py source/module origin omitted by the parent metadata filter; all earlier runtime file/path pins are unchanged. The actual failed v1 operation remains STOP before component import; this repair creates no retry permission. This is a trusted finite local CPython3.12/Linux host contract with no hostile concurrent module/loader/file mutation. Recorded interpreter/source/extension/library hashes and module origins do not establish arbitrary host/process-memory attestation or original complete H25 custody. The parent separately authenticates its runner, launcher, manifest anchors and complete stage before launch and after exit. + +The existing guard remains byte unchanged, including its600/2400 phase contract. The parent owns existing-budget accounting, exact launch/timeout cleanup and resource admission. Source-only preparation does not reset or create any allowance. Parent-reported immutable failed-attempt ledger totals66.090533479 policy seconds. A new set of four outer reservations of122.01seconds each totals488.04seconds; parent must independently verify any proposed admission/accounting against the unchanged initial600 budget. This document does not approve those reservations. Actual charged results, failures, metadata costs and outer cleanup still require parent reconciliation. Timeout behavior, cleanup and resource fit have not been exercised by this source author. + +The complete per-operation bill includes startup/imports; two full runtime and package read/hash traversals; manifest parsing; file inventories, metadata and module-origin checks; the frozen consumer's complete control/fixture/setup/serialization/readback work; adapter-boundary serialization/write; stdout, close and exit; outer guard/launcher and independent validation. Runtime-pin materialization, this source preparation and final metadata publication physical costs remain outside complete measured closure and are not zero. No actual execution, measurement, source self-approval or performance claim exists here. + +This one source repair copies the exact v1 adapter and JOBS unchanged. `SOURCE-AUDIT.json` records the bounded source inspection of startup and ordinary import paths, plus error/help-path limitations. No actual startup, probe, helper, target import, test, measurement or retry was performed by this author. diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/RUNTIME-PINS.json b/research/h25-bounded-serializer/validation/execution-source-v2/RUNTIME-PINS.json new file mode 100644 index 0000000000..0a5932ca34 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/RUNTIME-PINS.json @@ -0,0 +1,466 @@ +{ + "assumptions": [ + "Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.", + "File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.", + "Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.", + "Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.", + "Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.", + "Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption." + ], + "created_utc": "2026-10-31T04:40:08.521435+00:00", + "environment": { + "LC_ALL": "C.UTF-8", + "PYTHONDONTWRITEBYTECODE": "1", + "PYTHONHASHSEED": "0", + "PYTHONNOUSERSITE": "1", + "PYTHONSAFEPATH": "1", + "TZ": "UTC" + }, + "executable_realpath": "/usr/bin/python3.12", + "files": { + "/etc/python3.12/sitecustomize.py": { + "bytes": 155, + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e" + }, + "/usr/bin/python3.12": { + "bytes": 8020928, + "sha256": "e50d468e8b0adfb05733f5b87b3cff34829c4a8c1aea50c865aa8bdfe4bb150f" + }, + "/usr/lib/python3.12/__future__.py": { + "bytes": 5218, + "sha256": "981d4c398849f9ebcab72300d9c1fe288fd6d7f28957b3b3fa3a493a5836d95c" + }, + "/usr/lib/python3.12/_collections_abc.py": { + "bytes": 32082, + "sha256": "90324ee3e1c4ca5319f7242d4b7c1e90eb8418b3f999d07c853aa488356282e6" + }, + "/usr/lib/python3.12/_compression.py": { + "bytes": 5681, + "sha256": "3ad5d60627477a60939ee44fc1bb3a05dbe8fb52f0f75039b8f5d8f1a278b981" + }, + "/usr/lib/python3.12/_sitebuiltins.py": { + "bytes": 3128, + "sha256": "b9388bc1d6d12ed6be12da420ab1feca40f99c0e33ec315d92b1e01cb69b25bc" + }, + "/usr/lib/python3.12/_weakrefset.py": { + "bytes": 5893, + "sha256": "91895a451d06e9f521a1171b31b9b19bc9740f35af00d4fa106338ab7167c9ac" + }, + "/usr/lib/python3.12/abc.py": { + "bytes": 6538, + "sha256": "e558702a95cdce3febd289da021715d2b92bc43995b8a1bc58dfa1c3d8010287" + }, + "/usr/lib/python3.12/argparse.py": { + "bytes": 101750, + "sha256": "29395feb61bc376ca4ff9d44069af8d914ec2a1f25a4bd7978f6e2afef5bc07f" + }, + "/usr/lib/python3.12/bisect.py": { + "bytes": 3423, + "sha256": "f1cf7b85fc36b5da249813fc5ab97d9464f8cc1bc817f7146206fa2713e35999" + }, + "/usr/lib/python3.12/bz2.py": { + "bytes": 11847, + "sha256": "76ab3252924e71e859d7d90e8d3db13b6554975cfcac0fdadced4de7f8779330" + }, + "/usr/lib/python3.12/codecs.py": { + "bytes": 36870, + "sha256": "7b7839e53a77961153240aecfe11edc8054d05b1dedd83894450dae21ec05785" + }, + "/usr/lib/python3.12/collections/__init__.py": { + "bytes": 52378, + "sha256": "0af967cd58036507b3d0fbc33b7a996c61dbb52a94b0b738c8bef12cd4cc7dd4" + }, + "/usr/lib/python3.12/collections/abc.py": { + "bytes": 119, + "sha256": "9cb4208f99128a0489b6c8e6c61637617dd7d4250c59e065491957eda084dd10" + }, + "/usr/lib/python3.12/contextlib.py": { + "bytes": 27637, + "sha256": "8b7a477f978a8532852fd81e241c78182516bc4975d672d580a5848a76e11eb6" + }, + "/usr/lib/python3.12/copy.py": { + "bytes": 8412, + "sha256": "cbd25547933176fcf6bb05c2adc9f4796d15ac20b9b82dcf890daea7203daeab" + }, + "/usr/lib/python3.12/copyreg.py": { + "bytes": 7614, + "sha256": "c8eda41f05c6bf95a4da4726a530409d2485ae060b8d019b3a8034389a15d3e9" + }, + "/usr/lib/python3.12/datetime.py": { + "bytes": 268, + "sha256": "ef20dc6b3554cd585dddffdc573f1f9a7a54c522f2a3fb4576c44edbb1e14238" + }, + "/usr/lib/python3.12/encodings/__init__.py": { + "bytes": 5884, + "sha256": "78c4744d407690f321565488710b5aaf6486b5afa8d185637aa1e7633ab59cd8" + }, + "/usr/lib/python3.12/encodings/aliases.py": { + "bytes": 15677, + "sha256": "6fdcc49ba23a0203ae6cf28e608f8e6297d7c4d77d52e651db3cb49b9564c6d2" + }, + "/usr/lib/python3.12/encodings/utf_8.py": { + "bytes": 1005, + "sha256": "ba0cac060269583523ca9506473a755203037c57d466a11aa89a30a5f6756f3d" + }, + "/usr/lib/python3.12/enum.py": { + "bytes": 81636, + "sha256": "c8ead615c159598370295649eb296819ad4b40d50b200c4fec2d4269bf7af9ae" + }, + "/usr/lib/python3.12/fnmatch.py": { + "bytes": 5999, + "sha256": "6683da36e47af523f3f41e18ad244d837783e19e98911cc0b7415dea81494ebc" + }, + "/usr/lib/python3.12/functools.py": { + "bytes": 38126, + "sha256": "cca971c456e1bec8b751aecdf41466f34dbf72321ee0840627280ba2ccf9d033" + }, + "/usr/lib/python3.12/genericpath.py": { + "bytes": 5572, + "sha256": "2b0b35d2206778af4081cf81dd9b513876e72c35a55bec941402e1fa62b1f1aa" + }, + "/usr/lib/python3.12/gettext.py": { + "bytes": 21747, + "sha256": "1cc6fd33bdce3bb29c0c37ec9a2f5bf15a315e9776b329247e6675c028a8af39" + }, + "/usr/lib/python3.12/hashlib.py": { + "bytes": 9349, + "sha256": "6dbdebf270868b391080e21dc9687eddfaf321c965ad979f68d3f5c423c613ab" + }, + "/usr/lib/python3.12/importlib/__init__.py": { + "bytes": 4774, + "sha256": "c9e1b3dbc619ac31e7017ac43668a20200872c1c0e79ae379c0dab6ed399b730" + }, + "/usr/lib/python3.12/importlib/_abc.py": { + "bytes": 1354, + "sha256": "80aab7931dc999dee581c8b8b56fcd973fe156335a96ceeaf6acfc03cebf10e8" + }, + "/usr/lib/python3.12/importlib/_bootstrap.py": { + "bytes": 57056, + "sha256": "9653944363a4773cc32bbb34426024597a9d2ee4cd42e7912b4daf8cadfb53ed" + }, + "/usr/lib/python3.12/importlib/_bootstrap_external.py": { + "bytes": 69197, + "sha256": "97c6211750d63067712ad2cd74d50be33337f1fb1cd2c769022ced9b401edd92" + }, + "/usr/lib/python3.12/importlib/machinery.py": { + "bytes": 880, + "sha256": "d045cd7ecf2a12b6ecbfbef79eb114e87ef2ebd756f5b705f73e6f3266e3dede" + }, + "/usr/lib/python3.12/importlib/util.py": { + "bytes": 10840, + "sha256": "ca54e6458dbe521d591e5b8d9bb651ef929bfae946706c98470cdd569041a64f" + }, + "/usr/lib/python3.12/io.py": { + "bytes": 3582, + "sha256": "7cec3cb8ac004058dd0a5af246e6d950fb59c7ddd0058fda48bcb3fcb98d8822" + }, + "/usr/lib/python3.12/ipaddress.py": { + "bytes": 78294, + "sha256": "cc9831e239bd81c1480a12733bded744002d93815fd0d083c77aea348c956e67" + }, + "/usr/lib/python3.12/json/__init__.py": { + "bytes": 14020, + "sha256": "d5d41e2c29049515d295d81a6d40b4890fbec8d8482cfb401630f8ef2f77e4d5" + }, + "/usr/lib/python3.12/json/decoder.py": { + "bytes": 12473, + "sha256": "9f02654649816145bc76f8c210a5fe3ba1de142d4d97a1c93105732e747c285b" + }, + "/usr/lib/python3.12/json/encoder.py": { + "bytes": 16070, + "sha256": "af7bd40a0d0d0a3e726a9b4b3a2a543019f6ab97a340d0162a9c29ca9da97869" + }, + "/usr/lib/python3.12/json/scanner.py": { + "bytes": 2425, + "sha256": "8604d9d03786d0d509abb49e9f069337278ea988c244069ae8ca2c89acc2cb08" + }, + "/usr/lib/python3.12/keyword.py": { + "bytes": 1073, + "sha256": "18c2be738c04ad20ad375f6a71db34b3823c7f40b0340f5294d0e89f3c9b093b" + }, + "/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so": { + "bytes": 32112, + "sha256": "eff8df23cdc54d38ce9ca600d07c21ccfd7f22bd52a0720e599e6828d3e2eb76" + }, + "/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so": { + "bytes": 64368, + "sha256": "8dc6cda6dd9495b95a2bfb5b26e8cf06b72f36dc0213d958b9277a958287f0fe" + }, + "/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so": { + "bytes": 48952, + "sha256": "ca8e35c58f7bc8e27258c4af43651c941413bc6318903621253485b0395758a3" + }, + "/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so": { + "bytes": 49256, + "sha256": "cb298120e40f064dc047e638d911f8b3b0abf625bf1d6bd07902b46efd820fd7" + }, + "/usr/lib/python3.12/lib-dynload/resource.cpython-312-x86_64-linux-gnu.so": { + "bytes": 19432, + "sha256": "c8cc35580b497bf128cf8bb0e25efc36573a4f21a1c6877a91737fcd52e24907" + }, + "/usr/lib/python3.12/locale.py": { + "bytes": 78562, + "sha256": "d1134b7212bad37b7b81339061dc37a19a194aa183ec2cb60412cf365993b151" + }, + "/usr/lib/python3.12/lzma.py": { + "bytes": 13277, + "sha256": "58fb9d2fdc8a8af7b25e218f17ea3b51bdfa53bdf40f440ab33c605974ca5c2e" + }, + "/usr/lib/python3.12/ntpath.py": { + "bytes": 30027, + "sha256": "c4dd79bf103677daaad873952b89fc1f973425e7b250006cc35af4c164181da8" + }, + "/usr/lib/python3.12/operator.py": { + "bytes": 10965, + "sha256": "b2af20f67667203c1730e686cc5d0427becc94db4c97f1d3efe3ed2158473f6a" + }, + "/usr/lib/python3.12/os.py": { + "bytes": 39786, + "sha256": "316d1b7307fd851bded3423c9d437e0a383c725d993f0fcff2e8b749fe560b62" + }, + "/usr/lib/python3.12/pathlib.py": { + "bytes": 51153, + "sha256": "b43e134bf7479759838b4ecec3d78e0e67fdfde2d671c5c2d7886a47da93885d" + }, + "/usr/lib/python3.12/platform.py": { + "bytes": 43331, + "sha256": "ed0defe8ff7c116710493ffd099b566d3de686ab1b431a3d5401056798e59341" + }, + "/usr/lib/python3.12/posixpath.py": { + "bytes": 17623, + "sha256": "c443d7b8afad1717e7060ce49b3e04423058de56cd4246ee6bcc1ac962eb5c2b" + }, + "/usr/lib/python3.12/random.py": { + "bytes": 34683, + "sha256": "0693d4ded36916f5b07d6c395cc331dbf1011bb70e90daaa29eaa32490a09425" + }, + "/usr/lib/python3.12/re/__init__.py": { + "bytes": 16315, + "sha256": "8ff3c37c63b917fcf8dc8d50993a502292a3dc159e41de4f4018c72a53d1c07b" + }, + "/usr/lib/python3.12/re/_casefix.py": { + "bytes": 5446, + "sha256": "41572ac50cf96b04496e676d8a6708898bb8e752e06dad34ed4c50c5d8f1fe40" + }, + "/usr/lib/python3.12/re/_compiler.py": { + "bytes": 26089, + "sha256": "c05067f8bfa4c13cbbf1eedc4d5cafc9b621bcb6ebc5771ba0518a18095af15a" + }, + "/usr/lib/python3.12/re/_constants.py": { + "bytes": 5930, + "sha256": "fa4fdb200f238f9e7817b63892b0d69833d8165134801e775e10cc113348a375" + }, + "/usr/lib/python3.12/re/_parser.py": { + "bytes": 41201, + "sha256": "a51a85b37cf3f44ba7ff25754da5f31306e4ccfa6eb3c017f9d37bdf4e770840" + }, + "/usr/lib/python3.12/reprlib.py": { + "bytes": 6569, + "sha256": "8da31054076803065758311f54b18b8a616824941977d907dc3ee729228e9015" + }, + "/usr/lib/python3.12/selectors.py": { + "bytes": 19671, + "sha256": "1eeb102373e18c96311203f30c516e785bd8642275aa0bd66e43a284c9692385" + }, + "/usr/lib/python3.12/shutil.py": { + "bytes": 58120, + "sha256": "819e518cb7a539d09b2526138015541b34d2646afb9c2f6ae4ffd476d6a0fcf4" + }, + "/usr/lib/python3.12/signal.py": { + "bytes": 2495, + "sha256": "0363c964c90ac0b3e515de5749205e6e6454051a1211058375d84d91eab6071a" + }, + "/usr/lib/python3.12/site.py": { + "bytes": 23903, + "sha256": "619436355cbe91c3b29681ab486ee63f5f2e0a7d6274dfae747bdb94e60bca55" + }, + "/usr/lib/python3.12/stat.py": { + "bytes": 5485, + "sha256": "052af0327eae6941b69b05c088b3e748f79995635f80ac4cc7125eb333eb4c77" + }, + "/usr/lib/python3.12/subprocess.py": { + "bytes": 88725, + "sha256": "baa9f9138d8d20df6284f67e7d2e790f847f65e2c5370de322d54cccd737f2d9" + }, + "/usr/lib/python3.12/tempfile.py": { + "bytes": 37334, + "sha256": "8c8033ed1426ace79e07a6608887d2a1694d817d63d61b04c3d59339f24b4269" + }, + "/usr/lib/python3.12/threading.py": { + "bytes": 60123, + "sha256": "8273b4cf5b6f274b4993f5cae08634dd272c6952af9867ff9aa13ed446f1549b" + }, + "/usr/lib/python3.12/types.py": { + "bytes": 10993, + "sha256": "345474ef027a1273f353da9bdc1f7c18f65335e72e681bcc0376774cc51f2405" + }, + "/usr/lib/python3.12/urllib/__init__.py": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "/usr/lib/python3.12/urllib/parse.py": { + "bytes": 45591, + "sha256": "a67b5694763137dbac085adbf0c22821d435ec8ca22d3bd3786d2c9f4ee748d5" + }, + "/usr/lib/python3.12/warnings.py": { + "bytes": 21760, + "sha256": "8eb1bb88d0beb82ebecfe7ee5cf54ed9b77b4a7acee1989e392a65de42017c49" + }, + "/usr/lib/python3.12/weakref.py": { + "bytes": 21513, + "sha256": "56f8d313fb74019e53eb9287400702fbce788b7fe30e097b0b6e06296f3f080c" + }, + "/usr/lib/python3.12/zipimport.py": { + "bytes": 28132, + "sha256": "4ac94d92219c2e1c0d67ad3fff3753ec3a3756af62a36a2f696f02cd12d518f0" + }, + "/usr/lib/python3/dist-packages/_distutils_hack/__init__.py": { + "bytes": 6299, + "sha256": "46849a60a7cc85189cf6b5ac62b3f135004862ce6a96540a81c95ef6fbc4dc3e" + }, + "/usr/lib/python3/dist-packages/apport_python_hook.py": { + "bytes": 8695, + "sha256": "2aac4de740babcc6038483cccc7fa71f7f06405da9b9d102aafe8ac55f509c4b" + }, + "/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py": { + "bytes": 122, + "sha256": "c38b82e5f241e83edbbe9bcfdcb8747f11071b32fbc8b7c950e38260a0059edb" + }, + "/usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2": { + "bytes": 236616, + "sha256": "c20a2dc8917c755f02b94049356320fe1f62ac7d9f8994731f807d9df39302da" + }, + "/usr/lib/x86_64-linux-gnu/libbz2.so.1.0.4": { + "bytes": 78944, + "sha256": "cc08c9f50a8009ffd6391e0116a100369b11ca9238fa52392c019e6645b122a1" + }, + "/usr/lib/x86_64-linux-gnu/libc.so.6": { + "bytes": 2129424, + "sha256": "3a15d66867d83762c7f2f1e37359cb8f6c5743edb369c65285cb0b1c4f7498bf" + }, + "/usr/lib/x86_64-linux-gnu/libcrypto.so.3": { + "bytes": 5309400, + "sha256": "6866ed711dab8927e1bf82bf1cd30e828bdfc34f3cc1e83b1c9eb01ce6c37d9a" + }, + "/usr/lib/x86_64-linux-gnu/libexpat.so.1.9.1": { + "bytes": 186624, + "sha256": "286682ecbc5e59a638963b1a4e6351e65eb32fcf4bdcb9cb7569b6a61fe06a8d" + }, + "/usr/lib/x86_64-linux-gnu/liblzma.so.5.4.5": { + "bytes": 202904, + "sha256": "26b37d25f7ca2a2d348de8ecabacda12e921cd933b21fa069a179760db77219d" + }, + "/usr/lib/x86_64-linux-gnu/libm.so.6": { + "bytes": 952616, + "sha256": "fce00b6f25f459cf4ae0b7fae4257909a1a8a86f9149e7c029a5d617baf1ccd0" + }, + "/usr/lib/x86_64-linux-gnu/libz.so.1.3": { + "bytes": 113000, + "sha256": "f61677c7bdb7c2aa2a243ea781bfd16afcb361cede7b4ef76127a9d8eb9a5242" + } + }, + "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", + "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.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", + "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", + "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" + }, + "observed_file_backed_libraries": [ + "/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" + ], + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/control/RUNTIME-PINS-v2.json", + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c" + }, + "python_version": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", + "repair": "Add omitted system-site hook whose resolved source path is /etc/python3.12/sitecustomize.py; retain failed v2 inventory and all source/control bytes.", + "schema": "serializer-finite-runtime-pins-v1" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/RUNTIME-PINS.sha256 b/research/h25-bounded-serializer/validation/execution-source-v2/RUNTIME-PINS.sha256 new file mode 100644 index 0000000000..5fbdfb0aa5 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/RUNTIME-PINS.sha256 @@ -0,0 +1 @@ +972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02 diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/SOURCE-AUDIT.json b/research/h25-bounded-serializer/validation/execution-source-v2/SOURCE-AUDIT.json new file mode 100644 index 0000000000..b813e52e80 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/SOURCE-AUDIT.json @@ -0,0 +1,76 @@ +{ + "actual_failure_context": "Parent reports v1 STOP in custody before component import because sitecustomize origin missing; frozen v1 and its failure retained", + "conditional_exit_limitations": [ + "ArgumentParser help/usage error formatting can lazily import textwrap; gettext compiled-translation parsing can import struct. Four declared successful commands do not request help or malformed arguments. Any undeclared path still fails closed if a file-backed origin is missing.", + "System apport uncaught-exception hook can import traceback/apport modules after adapter finally. A primary failed command is already STOP; adapter custody is not an assertion of all error-hook work after finally or process-wide post-exit runtime closure. Outer guard retains/charges failure evidence.", + "Trusted finite-host/no hostile concurrent mutation and parent system-site/cached-bytecode assumptions are retained; no whole-H25 or arbitrary runtime attestation is claimed." + ], + "direct_execution_source_imports": { + "bounded_serialization.py": [ + "__future__", + "_json", + "contextlib", + "hashlib", + "json", + "json.encoder", + "os", + "pathlib", + "stat", + "tempfile", + "types" + ], + "component_consumer.py": [ + "__future__", + "argparse", + "bounded_serialization", + "hashlib", + "json", + "pathlib", + "reference", + "serialization_controls", + "sys", + "types" + ], + "integration/full_driver.py": [ + "argparse", + "component_consumer", + "hashlib", + "json", + "os", + "stat", + "sys" + ], + "reference.py": [ + "hashlib", + "json" + ], + "serialization_controls.py": [ + "__future__", + "bounded_serialization", + "copy", + "hashlib", + "json", + "pathlib", + "sys", + "types" + ] + }, + "execution_admission": false, + "method": "AST/source inspection and existing parent metadata only; no target imports, probes, helper execution or tests", + "new_budget": false, + "ordinary_component_closure": "Direct local imports are exact package files. Direct standard-library imports have existing parent module/source entries; relevant tempfile/random/shutil/copy/json source imports use parent-pinned ordinary sources/extensions or builtin modules. No additional concrete missing ordinary source origin identified from these sources and existing metadata. This is not an observed live post-import module census.", + "performance_claim": null, + "repair": "Parent runtime-v3 adds only exact sitecustomize module/file; unchanged executable adapter and JOBS", + "schema": "serializer-runtime-origin-source-repair-audit-v2", + "startup_source_findings": [ + { + "finding": "Only source import is apport_python_hook, already in parent module/file pins; install uses already-pinned sys and conditionally os.", + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e", + "source": "/etc/python3.12/sitecustomize.py" + }, + { + "finding": "execsitecustomize imports sitecustomize; usercustomize executes only if ENABLE_USER_SITE, and declared no_user_site flag is required. No new user customization is admitted.", + "source": "/usr/lib/python3.12/site.py" + } + ] +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/SOURCE-PINS.json b/research/h25-bounded-serializer/validation/execution-source-v2/SOURCE-PINS.json new file mode 100644 index 0000000000..70fbf764b5 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/SOURCE-PINS.json @@ -0,0 +1,42 @@ +{ + "execution_admission": false, + "files": { + "INVENTORY-PROPOSED.json": { + "bytes": 2868, + "mode": 292, + "sha256": "79dd74bfeec00f8ff0b2071214fe365748dedd46bac2e7f221e925802374c178" + }, + "JOBS.json": { + "bytes": 497, + "mode": 292, + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + "README.md": { + "bytes": 4484, + "mode": 292, + "sha256": "150f3a390d197a7ab51d4b808b22fcb846f758487e306da6a8a086ec5b0e8b3d" + }, + "RUNTIME-PINS.json": { + "bytes": 20649, + "mode": 292, + "sha256": "972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02" + }, + "RUNTIME-PINS.sha256": { + "bytes": 65, + "mode": 292, + "sha256": "c6cacd389499df0b6834d2f4605c839877b112bdf0850a8a5e3776d5051c070f" + }, + "SOURCE-AUDIT.json": { + "bytes": 3297, + "mode": 292, + "sha256": "f98293ad9d29eea90e4b96cb2f9f9d3b876ddc266d5f29ebbcaa63b88af747d8" + }, + "integration/full_driver.py": { + "bytes": 8418, + "mode": 292, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + } + }, + "schema": "serializer-fixed-execution-source-pins-v2", + "status": "ONE_SOURCE_REPAIR_PENDING_NEW_INDEPENDENT_REVIEW" +} diff --git a/research/h25-bounded-serializer/validation/execution-source-v2/integration/full_driver.py b/research/h25-bounded-serializer/validation/execution-source-v2/integration/full_driver.py new file mode 100644 index 0000000000..c96966772f --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-source-v2/integration/full_driver.py @@ -0,0 +1,177 @@ +"""Four fixed finite serializer operations under the unchanged parent guard. + +Trusted finite host, no hostile concurrent mutation. This authenticates declared +files/origins, not arbitrary process memory or original complete H25 custody. +""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import stat +import sys + +STAGE = Path(__file__).resolve().parents[1] +PACKAGE = STAGE / "package" +PACKAGE_SHA256 = "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" +LOCAL = ("component_consumer", "reference", "bounded_serialization", "serialization_controls") +ENV = {"PYTHONHASHSEED": "0", "LC_ALL": "C.UTF-8", "TZ": "UTC", + "PYTHONDONTWRITEBYTECODE": "1", "PYTHONNOUSERSITE": "1", "PYTHONSAFEPATH": "1"} +LANES = {"serializer-controls": "controls", "serializer-baseline-2048": "baseline", + "serializer-candidate-2048": "candidate"} + + +def need(condition, message): + if not condition: + raise RuntimeError(message) + + +def small(path): + with path.open("rb") as stream: + raw = stream.read(1048577) + need(len(raw) <= 1048576, "Custody metadata exceeded 1MiB") + return raw + + +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 file_pin(path): + need(path.is_absolute() and path.resolve() == path, "Pin path must be resolved absolute") + before = path.lstat() + 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()) + need(stat.S_ISREG(opened.st_mode), "Pin is not a regular file") + count, hasher = 0, hashlib.sha256() + while count < opened.st_size: + raw = stream.read(min(1048576, opened.st_size - count)) + need(bool(raw), "Pinned file ended early") + hasher.update(raw) + count += len(raw) + after = os.fstat(stream.fileno()) + need(identity(before) == identity(opened) == identity(after) == identity(path.lstat()), + "Pinned file changed while hashing") + return {"bytes": count, "sha256": hasher.hexdigest()} + + +def origins(runtime): + observed = {} + for name, module in tuple(sys.modules.items()): + filename = getattr(module, "__file__", None) + if filename is None: + continue + actual = str(Path(filename).resolve()) + if name == "__main__": + expected = str(Path(__file__).resolve()) + elif name in LOCAL: + expected = str(PACKAGE / (name + ".py")) + else: + expected = runtime["module_paths"].get(name) + need(actual == expected, "Unadmitted file-backed module origin: " + name) + observed[name] = actual + return observed + + +def custody(anchor): + need(small(STAGE / "RUNTIME-PINS.sha256") == anchor, "Runtime anchor changed") + expected_runtime = anchor.decode("ascii").strip() + need(len(expected_runtime) == 64 and all(c in "0123456789abcdef" for c in expected_runtime), + "Malformed parent runtime anchor") + runtime_raw = small(STAGE / "RUNTIME-PINS.json") + need(hashlib.sha256(runtime_raw).hexdigest() == expected_runtime, + "Runtime manifest differs from independent parent anchor") + runtime = json.loads(runtime_raw) + need(runtime["schema"] == "serializer-finite-runtime-pins-v1", "Runtime schema differs") + need(runtime["python_version"] == sys.version and + runtime["executable_realpath"] == str(Path(sys.executable).resolve()) == "/usr/bin/python3.12", + "Interpreter differs from parent runtime") + need(runtime["environment"] == ENV and all(os.environ.get(k) == v for k, v in ENV.items()), + "Finite environment differs") + need(not any(name in os.environ for name in + ("PYTHONPATH", "PYTHONOPTIMIZE", "PYTHONINSPECT", "PYTHONSTARTUP", "PYTHONPYCACHEPREFIX")), + "Forbidden Python startup environment") + need(sys.flags.no_user_site == 1 and sys.flags.safe_path and sys.dont_write_bytecode, + "Required finite startup flags absent") + package_raw = small(PACKAGE / "SOURCE-PINS.json") + need(hashlib.sha256(package_raw).hexdigest() == PACKAGE_SHA256, "Serializer manifest changed") + package = json.loads(package_raw) + expected_paths = set(package["files"]) | {"SOURCE-PINS.json"} + actual_paths = set() + for path in PACKAGE.rglob("*"): + need(not path.is_symlink(), "Symlink in frozen serializer") + if path.is_file(): + actual_paths.add(str(path.relative_to(PACKAGE))) + need(actual_paths == expected_paths, "Serializer file inventory changed") + for relative, pin in package["files"].items(): + path = PACKAGE / relative + need(file_pin(path) == {"bytes": pin["bytes"], "sha256": pin["sha256"]} and + oct(stat.S_IMODE(path.stat().st_mode)) == pin["mode_octal"], + "Serializer payload changed: " + relative) + for filename, pin in runtime["files"].items(): + need(file_pin(Path(filename)) == pin, "Runtime file changed: " + filename) + return {"runtime_manifest_sha256": expected_runtime, "runtime_file_count": len(runtime["files"]), + "serializer_manifest_sha256": PACKAGE_SHA256, "serializer_payload_files": len(package["files"]), + "module_origins": origins(runtime), "assumptions": runtime["assumptions"]} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--lanes", choices=tuple(LANES), required=True) + parser.add_argument("--finite-only", action="store_true") + args = parser.parse_args() + need(args.finite_only, "This adapter admits only fixed finite operations") + mode = LANES[args.lanes] + need(sys.flags.optimize in ((0, 1) if mode == "controls" else (0,)), "Undeclared optimization mode") + need(not args.output.exists(), "Refusing earlier adapter evidence") + args.output.mkdir(parents=True) + boundary = {"scope": "Supported finite serializer host only; no full H25 custody/performance claim", + "mode": mode, "fixture_rows": None if mode == "controls" else 2048, + "python_version": sys.version, "executable": sys.executable, + "executable_realpath": str(Path(sys.executable).resolve()), + "optimization": sys.flags.optimize, "no_user_site": sys.flags.no_user_site, + "safe_path": sys.flags.safe_path, "dont_write_bytecode": sys.dont_write_bytecode, + "environment": {key: os.environ.get(key) for key in ENV}, "status": "STARTED"} + primary, post_error, anchor = None, None, None + try: + anchor = small(STAGE / "RUNTIME-PINS.sha256") + boundary["before"] = custody(anchor) + need(not any(name in sys.modules for name in LOCAL), "Component module preloaded") + sys.path.insert(0, str(PACKAGE)) + import component_consumer + need(Path(component_consumer.__file__).resolve() == PACKAGE / "component_consumer.py", + "Actual consumer source differs") + receipt = component_consumer.run_component(mode, args.output / "component", rows=2048) + boundary["component_status"] = receipt["status"] + boundary["status"] = "FINITE_COMPONENT_RETURNED" + except BaseException as error: + primary = error + boundary["status"] = "PRIMARY_ERROR" + boundary["primary_error_type"] = type(error).__name__ + raise + finally: + try: + need(anchor is not None, "Runtime anchor was not obtained") + boundary["after"] = custody(anchor) + except BaseException as error: + post_error = error + boundary["postcheck_error_type"] = type(error).__name__ + if primary is None: + boundary["status"] = "POSTCHECK_ERROR" + try: + (args.output / "adapter-boundary.json").write_text(json.dumps(boundary, sort_keys=True, indent=2) + + "\n", encoding="utf-8") + except BaseException: + if primary is None and post_error is None: + raise + if primary is None and post_error is not None: + raise post_error + print(json.dumps({"status": boundary["status"], "mode": mode, + "optimization": sys.flags.optimize}, sort_keys=True)) + + +if __name__ == "__main__": + main() diff --git a/research/h25-bounded-serializer/validation/execution-v1-STAGE.json b/research/h25-bounded-serializer/validation/execution-v1-STAGE.json new file mode 100644 index 0000000000..e8a9b3014f --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-STAGE.json @@ -0,0 +1,111 @@ +{ + "created_utc": "2026-10-31T04:35:00.266773+00:00", + "files": { + "JOBS.json": { + "mode": 292, + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + "RUNTIME-PINS.json": { + "mode": 292, + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c" + }, + "RUNTIME-PINS.sha256": { + "mode": 292, + "sha256": "3f19eff68ec00a26632c5049950387ca94d5124dd11807f7fa0c81ee91abfc71" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + }, + "package/BILL.json": { + "mode": 292, + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + "package/CONTROL-SPEC.json": { + "mode": 292, + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "package/FEASIBILITY.json": { + "mode": 292, + "sha256": "f9ff50549bae4071fb7531fe6ad2e53d2b593b8508d42dce6194ea7c3e012a61" + }, + "package/ORIGINAL-SOURCE-PINS.json": { + "mode": 292, + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "package/README.md": { + "mode": 292, + "sha256": "c74cc98f237a4ed97c77ec77555322b496c5e8a5f7544864dc55b584cc19a104" + }, + "package/REFERENCE-EXTRACTION.json": { + "mode": 292, + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "package/SOURCE-PINS.json": { + "mode": 292, + "sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" + }, + "package/bounded_serialization.py": { + "mode": 292, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "package/component_consumer.py": { + "mode": 292, + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + "package/docs/API-v2.md": { + "mode": 292, + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "package/docs/API-v3.md": { + "mode": 292, + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "package/docs/CONTRACT-v2.json": { + "mode": 292, + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "package/docs/COST-CONTROLS.json": { + "mode": 292, + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "package/docs/SOURCE-READINESS-v3.json": { + "mode": 292, + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "package/provenance/PROPOSAL.json": { + "mode": 292, + "sha256": "9bf3f21b0b2c3db755495e5b6c4ba1b6a76e18f43f8fc1563ae31a808a1ea0ee" + }, + "package/provenance/REVIEW-v3.json": { + "mode": 292, + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + "package/provenance/SOURCE-DESIGN.md": { + "mode": 292, + "sha256": "0a12cb7945e4bb772154346c61a202b9f44e7297800306ef9ce113373af77578" + }, + "package/provenance/compare_side_verifier.py": { + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "package/provenance/native_backend.py": { + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "package/provenance/profile_side_verifier.py": { + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "package/reference.py": { + "mode": 292, + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "package/serialization_controls.py": { + "mode": 292, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", + "schema": "serializer-immutable-stage-v1" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.stderr.txt b/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.stdout.txt b/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.stdout.txt new file mode 100644 index 0000000000..ab729c3cf5 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.stdout.txt @@ -0,0 +1 @@ +{"budget_phase_sha256": "529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32", "command": ["/usr/bin/python3.12", "-B", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py", "--output", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/science", "--lanes", "serializer-controls", "--finite-only"], "exit": 1, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "serializer-controls-normal", "label": "serializer-controls-normal", "log_read_chunk_bytes": 65536, "output_cap_observed_at": null, "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "retained_log_bytes_stable": true, "runner_lifetime_max_rss_kib": 18176, "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", "runner_system_seconds": 0.0011660000000000004, "runner_user_seconds": 0.012484999999999996, "runner_wall_seconds": 0.2644113269634545, "sampled_process_group_rss_bytes": 31526912, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.0, "stage_sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c", "status": "STOP", "stderr_bytes": 1635, "stderr_final_bytes": 1635, "stderr_sha256": "59a2dddcb39107e516cec72edcb661cf9e22c54d62be0676634b8e4049e28ddf", "stdout_bytes": 0, "stdout_final_bytes": 0, "stdout_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "termination": null, "usage": {"raw": "Command exited with non-zero status 1\n{\"user_seconds\":0.20,\"system_seconds\":0.02,\"kernel_max_rss_kib\":31504,\"exit\":1}\n"}, "wall_seconds": 0.25436667492613196} diff --git a/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.time.txt b/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.time.txt new file mode 100644 index 0000000000..b40356e6f4 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-attempts/serializer-controls-normal.time.txt @@ -0,0 +1,6 @@ +Command exited with non-zero status 1 +wall_seconds=0.31 +user_seconds=0.25 +system_seconds=0.04 +max_rss_kib=31504 +exit=1 diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/ADMISSION-001.json b/research/h25-bounded-serializer/validation/execution-v1-control/ADMISSION-001.json new file mode 100644 index 0000000000..8addec2376 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/ADMISSION-001.json @@ -0,0 +1,52 @@ +{ + "all_sources_checked_current": true, + "attempt_number": 1, + "created_utc": "2026-10-31T04:38:17.128230+00:00", + "full_physical_boundary": "OPEN_NOT_ZERO", + "independent_review": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/EXACT-OPERATION-REVIEW-v2.json", + "sha256": "8ecd22a37b18a569f462f0250938023b92975a030280e8efa75f5b3b20bc09c4" + }, + "maximum_if_used_seconds": "185.780533479", + "no_retry": true, + "operation": { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-controls-normal", + "serializer-controls-normal" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-normal", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stdout.txt" + }, + "parent_admitted": true, + "policy_reserved_seconds": "122.01", + "prior_policy_seconds": "63.770533479", + "proposal": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/OPERATION-PROPOSAL-v2.json", + "sha256": "788cd8fbb6c0c9efc5402990fc6c58d17bf761d6d337c450d15a4f6cdc96e8ac" + }, + "schema": "serializer-one-use-admission-v1" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/COMMAND-001.json b/research/h25-bounded-serializer/validation/execution-v1-control/COMMAND-001.json new file mode 100644 index 0000000000..5f2374c5a6 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/COMMAND-001.json @@ -0,0 +1 @@ +{"command": "/usr/bin/env PYTHONNOUSERSITE=1 PYTHONSAFEPATH=1 /usr/bin/flock -n /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock /usr/bin/time -f 'wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x' -o /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt /usr/bin/timeout --signal=INT --kill-after=3s 117s /usr/bin/python3.12 -B /home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py serializer-v1 serializer-controls-normal serializer-controls-normal >/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stdout.txt 2>/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stderr.txt", "admission_sha256": "48dd0f78b67e1bfbe7b2ca451c679a90ad595f528d7a10fe00258da0c81249d9"} diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/EXECUTION-PHASE.json b/research/h25-bounded-serializer/validation/execution-v1-control/EXECUTION-PHASE.json new file mode 100644 index 0000000000..d08468bea8 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/EXECUTION-PHASE.json @@ -0,0 +1,7 @@ +{ + "aggregate_cap_seconds": 600, + "maximum_prior_plus_reservation_seconds": "551.810533479", + "maximum_reserved_four_commands_seconds": "488.04", + "prior_policy_seconds": "63.770533479", + "scope": "fresh namespace internal cap only; prior+new enforced by parent one-use admissions" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/LAUNCHER-PINS-v1.json b/research/h25-bounded-serializer/validation/execution-v1-control/LAUNCHER-PINS-v1.json new file mode 100644 index 0000000000..117cad2ba9 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/LAUNCHER-PINS-v1.json @@ -0,0 +1,25 @@ +{ + "files": { + "/usr/bin/env": { + "bytes": 48072, + "realpath": "/usr/bin/env", + "sha256": "886e5fa8be716b03eeda48856e0f04493f2969fc148fb7812594ffac647fa050" + }, + "/usr/bin/flock": { + "bytes": 23024, + "realpath": "/usr/bin/flock", + "sha256": "e619344dc3eec4023498465679262f9ca27d1e8cef9cfc4c1ae72b428577b806" + }, + "/usr/bin/time": { + "bytes": 27160, + "realpath": "/usr/bin/time", + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10" + }, + "/usr/bin/timeout": { + "bytes": 39880, + "realpath": "/usr/bin/timeout", + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52" + } + }, + "scope": "Trusted finite local launcher files; no whole-host attestation" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/LEDGER-001.json b/research/h25-bounded-serializer/validation/execution-v1-control/LEDGER-001.json new file mode 100644 index 0000000000..413041733e --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/LEDGER-001.json @@ -0,0 +1,47 @@ +{ + "attempt_policy_seconds": "2.32", + "automatic_retry": false, + "combined_round_policy_seconds": "66.090533479", + "controls_completed": 0, + "created_utc": "2026-10-31T04:40:08.521435+00:00", + "evidence": { + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt": { + "bytes": 119, + "sha256": "d5d32f91891738afa592aefbe405c68ba8dcec1fffad66d5cc25d1063e5962b9" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/START.json": { + "bytes": 1073, + "sha256": "5a5cb57fd9ef2e8a3d8b9827cfb7e666d872f4dd215a1475f95396189b86f89e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/receipt.json": { + "bytes": 2108, + "sha256": "c5908920fefde3b20a25290f0b38b5dbd9fcd237cd73a51ad23ec7c50531ba2d" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/stderr.txt": { + "bytes": 1635, + "sha256": "59a2dddcb39107e516cec72edcb661cf9e22c54d62be0676634b8e4049e28ddf" + } + }, + "historical_gap_preserved": true, + "label": "serializer-controls-normal", + "nominal_admin_seconds": "2", + "outer_GNU_time": { + "exit": "1", + "max_rss_kib": "31504", + "system_seconds": "0.04", + "user_seconds": "0.25", + "wall_seconds": "0.31" + }, + "physical_boundary": "OPEN_NOT_ZERO", + "physical_total_seconds": null, + "previous_ledger": { + "path": "outputs/h25-stable-packages-publication-20261031/control/VALIDATION-LEDGER-006.json", + "sha256": "df16cd790ef27f3008399d73ea2ad068d2fab7e844a713fd96244430ed3e7b2a" + }, + "prior_policy_seconds": "63.770533479", + "reason": "Unadmitted file-backed module origin: sitecustomize", + "remaining_three_original_operations_cancelled": true, + "rounding_margin_seconds": ".01", + "schema": "serializer-operation-accounting-v1", + "status": "STOP_BEFORE_COMPONENT_IMPORT" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/OPERATION-PROPOSAL-v1.json b/research/h25-bounded-serializer/validation/execution-v1-control/OPERATION-PROPOSAL-v1.json new file mode 100644 index 0000000000..14b0d06198 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/OPERATION-PROPOSAL-v1.json @@ -0,0 +1,160 @@ +{ + "created_utc": "2026-10-31T04:35:00.267790+00:00", + "execution_admission": false, + "failure_rule": "Any nonzero, timeout, bad/unclosed receipt, changed custody or independent rejection stops dispatch. Retain and charge attempts. No retry/reroll. No cleanup inference after interruption.", + "independent_readback": "Parent checks exact70 ordered names/mode, baseline/candidate complete artifact bytes/hashes/counts, guard logs/custody/cost retained metadata without target imports.", + "operations": [ + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-controls-normal", + "serializer-controls-normal" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-normal", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-controls-O", + "serializer-controls-O" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-O", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-O", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-baseline-2048", + "serializer-baseline-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-baseline-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-baseline-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-candidate-2048", + "serializer-candidate-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-candidate-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-candidate-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.stdout.txt" + } + ], + "outer_timeout": "SIGINT at117s reaches Python guard finally; SIGKILL fallback3s. Trusted responsive local filesystem, bounded purePython/stdlib finite fixture only; arbitrary hostile runtime and uninterruptible IO not attested.", + "phase": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/EXECUTION-PHASE.json", + "sha256": "529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32" + }, + "reservation": { + "initial_cap_seconds": 600, + "max_total_policy_seconds": "551.810533479", + "no_new_budget": true, + "operations": 4, + "per_command_seconds": "122.01", + "prior_policy_seconds": "63.770533479", + "total_cap_seconds": 2400 + }, + "runner": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + }, + "schema": "serializer-parent-four-operation-proposal-v1", + "stage": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/STAGE.json", + "sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c" + }, + "whole_physical_boundary": "OPEN_NOT_ZERO; nominal2secadmin+.01GNUrounding perattempt; external metadata/readback/publication residual unknown" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-control/OPERATION-PROPOSAL-v2.json b/research/h25-bounded-serializer/validation/execution-v1-control/OPERATION-PROPOSAL-v2.json new file mode 100644 index 0000000000..c22d186183 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-control/OPERATION-PROPOSAL-v2.json @@ -0,0 +1,168 @@ +{ + "created_utc": "2026-10-31T04:35:00.267790+00:00", + "execution_admission": false, + "failure_rule": "Any nonzero, timeout, bad/unclosed receipt, changed custody or independent rejection stops dispatch. Retain and charge attempts. No retry/reroll. No cleanup inference after interruption.", + "independent_readback": "Parent checks exact70 ordered names/mode, baseline/candidate complete artifact bytes/hashes/counts, guard logs/custody/cost retained metadata without target imports.", + "launchers": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LAUNCHER-PINS-v1.json", + "sha256": "51a09ea4c1fa9b46c3767b65ca93663584b6cb5ad8266a891da6a8ff98ead4da" + }, + "operations": [ + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-controls-normal", + "serializer-controls-normal" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-normal", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-controls-O", + "serializer-controls-O" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-O", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-O", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-baseline-2048", + "serializer-baseline-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-baseline-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-baseline-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "serializer-v1", + "serializer-candidate-2048", + "serializer-candidate-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-candidate-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-candidate-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.stdout.txt" + } + ], + "outer_timeout": "SIGINT at117s reaches Python guard finally; SIGKILL fallback3s. Trusted responsive local filesystem, bounded purePython/stdlib finite fixture only; arbitrary hostile runtime and uninterruptible IO not attested.", + "phase": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/EXECUTION-PHASE.json", + "sha256": "529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32" + }, + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/OPERATION-PROPOSAL-v1.json", + "sha256": "a332a9e94833321960a2ad7aa79cafe0d16e6b26f1028ce6478dd47a7c24edb5" + }, + "reservation": { + "initial_cap_seconds": 600, + "max_total_policy_seconds": "551.810533479", + "no_new_budget": true, + "operations": 4, + "per_command_seconds": "122.01", + "prior_policy_seconds": "63.770533479", + "total_cap_seconds": 2400 + }, + "runner": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + }, + "schema": "serializer-parent-four-operation-proposal-v1", + "stage": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/STAGE.json", + "sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c" + }, + "whole_physical_boundary": "OPEN_NOT_ZERO; nominal2secadmin+.01GNUrounding perattempt; external metadata/readback/publication residual unknown" +} diff --git a/research/h25-bounded-serializer/validation/execution-v1-serializer-controls-normal-raw.json b/research/h25-bounded-serializer/validation/execution-v1-serializer-controls-normal-raw.json new file mode 100644 index 0000000000..385c740268 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v1-serializer-controls-normal-raw.json @@ -0,0 +1,44 @@ +{ + "file_count": 6, + "files": [ + { + "bytes": 1073, + "path": "START.json", + "sha256": "5a5cb57fd9ef2e8a3d8b9827cfb7e666d872f4dd215a1475f95396189b86f89e", + "utf8": "{\n \"budget_phase_sha256\": \"529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/science\",\n \"--lanes\",\n \"serializer-controls\",\n \"--finite-only\"\n ],\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-controls-normal\",\n \"label\": \"serializer-controls-normal\",\n \"phase_cap_seconds\": 600,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"spent_before_seconds\": 0.0,\n \"stage_sha256\": \"a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c\"\n}\n" + }, + { + "bytes": 2108, + "path": "receipt.json", + "sha256": "c5908920fefde3b20a25290f0b38b5dbd9fcd237cd73a51ad23ec7c50531ba2d", + "utf8": "{\n \"budget_phase_sha256\": \"529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/science\",\n \"--lanes\",\n \"serializer-controls\",\n \"--finite-only\"\n ],\n \"exit\": 1,\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-controls-normal\",\n \"label\": \"serializer-controls-normal\",\n \"log_read_chunk_bytes\": 65536,\n \"output_cap_observed_at\": null,\n \"phase_cap_seconds\": 600,\n \"platform\": \"Linux-7.0.0-38-generic-x86_64-with-glibc2.39\",\n \"python\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"retained_log_bytes_stable\": true,\n \"runner_lifetime_max_rss_kib\": 18176,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"runner_system_seconds\": 0.0011660000000000004,\n \"runner_user_seconds\": 0.012484999999999996,\n \"runner_wall_seconds\": 0.2644113269634545,\n \"sampled_process_group_rss_bytes\": 31526912,\n \"source_bytes_and_modes_unchanged\": true,\n \"spent_before_seconds\": 0.0,\n \"stage_sha256\": \"a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c\",\n \"status\": \"STOP\",\n \"stderr_bytes\": 1635,\n \"stderr_final_bytes\": 1635,\n \"stderr_sha256\": \"59a2dddcb39107e516cec72edcb661cf9e22c54d62be0676634b8e4049e28ddf\",\n \"stdout_bytes\": 0,\n \"stdout_final_bytes\": 0,\n \"stdout_sha256\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\n \"termination\": null,\n \"usage\": {\n \"raw\": \"Command exited with non-zero status 1\\n{\\\"user_seconds\\\":0.20,\\\"system_seconds\\\":0.02,\\\"kernel_max_rss_kib\\\":31504,\\\"exit\\\":1}\\n\"\n },\n \"wall_seconds\": 0.25436667492613196\n}\n" + }, + { + "bytes": 689, + "path": "science/adapter-boundary.json", + "sha256": "233809ac78d99a4a087c485e325c8d77545ee6a05a4cf5d05b1d80aefe634d18", + "utf8": "{\n \"dont_write_bytecode\": true,\n \"environment\": {\n \"LC_ALL\": \"C.UTF-8\",\n \"PYTHONDONTWRITEBYTECODE\": \"1\",\n \"PYTHONHASHSEED\": \"0\",\n \"PYTHONNOUSERSITE\": \"1\",\n \"PYTHONSAFEPATH\": \"1\",\n \"TZ\": \"UTC\"\n },\n \"executable\": \"/usr/bin/python3.12\",\n \"executable_realpath\": \"/usr/bin/python3.12\",\n \"fixture_rows\": null,\n \"mode\": \"controls\",\n \"no_user_site\": 1,\n \"optimization\": 0,\n \"postcheck_error_type\": \"RuntimeError\",\n \"primary_error_type\": \"RuntimeError\",\n \"python_version\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"safe_path\": true,\n \"scope\": \"Supported finite serializer host only; no full H25 custody/performance claim\",\n \"status\": \"PRIMARY_ERROR\"\n}\n" + }, + { + "bytes": 1635, + "path": "stderr.txt", + "sha256": "59a2dddcb39107e516cec72edcb661cf9e22c54d62be0676634b8e4049e28ddf", + "utf8": "Traceback (most recent call last):\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\", line 177, in \n main()\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\", line 141, in main\n boundary[\"before\"] = custody(anchor)\n ^^^^^^^^^^^^^^^\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\", line 117, in custody\n \"module_origins\": origins(runtime), \"assumptions\": runtime[\"assumptions\"]}\n ^^^^^^^^^^^^^^^^\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\", line 73, in origins\n need(actual == expected, \"Unadmitted file-backed module origin: \" + name)\n File \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py\", line 26, in need\n raise RuntimeError(message)\nRuntimeError: Unadmitted file-backed module origin: sitecustomize\n" + }, + { + "bytes": 0, + "path": "stdout.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 118, + "path": "usage.json", + "sha256": "ba375e5977fe102c8c62665ea8883f72fe3602f88cfba45d30cd706106666148", + "utf8": "Command exited with non-zero status 1\n{\"user_seconds\":0.20,\"system_seconds\":0.02,\"kernel_max_rss_kib\":31504,\"exit\":1}\n" + } + ], + "original_run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal", + "schema": "verbatim-finite-run-bundle-v1", + "total_bytes": 5623 +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-STAGE.json b/research/h25-bounded-serializer/validation/execution-v2-STAGE.json new file mode 100644 index 0000000000..246e0aedfa --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-STAGE.json @@ -0,0 +1,111 @@ +{ + "created_utc": "2026-10-31T04:43:12.083983+00:00", + "files": { + "JOBS.json": { + "mode": 292, + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + "RUNTIME-PINS.json": { + "mode": 292, + "sha256": "972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02" + }, + "RUNTIME-PINS.sha256": { + "mode": 292, + "sha256": "c6cacd389499df0b6834d2f4605c839877b112bdf0850a8a5e3776d5051c070f" + }, + "integration/full_driver.py": { + "mode": 292, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + }, + "package/BILL.json": { + "mode": 292, + "sha256": "1e771384c2dc404a7aafae91d578b3445921701ac80d7361404ec879873fac06" + }, + "package/CONTROL-SPEC.json": { + "mode": 292, + "sha256": "f6355b4469a28507d1743f37f30177c9bc6c71f1bd1e9cebd8b15b19c637d423" + }, + "package/FEASIBILITY.json": { + "mode": 292, + "sha256": "f9ff50549bae4071fb7531fe6ad2e53d2b593b8508d42dce6194ea7c3e012a61" + }, + "package/ORIGINAL-SOURCE-PINS.json": { + "mode": 292, + "sha256": "5d24c8b59e3843313a3b78b7ee7ab5f99ba4aa4ff7dac5b5a576679ee8e12930" + }, + "package/README.md": { + "mode": 292, + "sha256": "c74cc98f237a4ed97c77ec77555322b496c5e8a5f7544864dc55b584cc19a104" + }, + "package/REFERENCE-EXTRACTION.json": { + "mode": 292, + "sha256": "bfb4c0f8e883a0ecb5584b2ced8be6be92f491fa75feaebcf7e48955a652dd01" + }, + "package/SOURCE-PINS.json": { + "mode": 292, + "sha256": "5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e" + }, + "package/bounded_serialization.py": { + "mode": 292, + "sha256": "4edd0ae36b0fe98fe99d8658391a52568cc59888f1ae11e69cbb01f9544c74cb" + }, + "package/component_consumer.py": { + "mode": 292, + "sha256": "360ee7838c00d4e07908e4a7343091397a5902660aead9f0a9f25c2e708242b1" + }, + "package/docs/API-v2.md": { + "mode": 292, + "sha256": "c8ed5f3aa87b433a5ea569622acef4f05d29dbfb7543e3b65d035d27da98fd87" + }, + "package/docs/API-v3.md": { + "mode": 292, + "sha256": "44f42b8f1575effc7f41ca76e914f0d32e71e45464f302f117d935f4aa27dcd6" + }, + "package/docs/CONTRACT-v2.json": { + "mode": 292, + "sha256": "10d011cf62573f4a2b5be30af1272c5fb94092fbaddc339a5ebd3a4c584e52e5" + }, + "package/docs/COST-CONTROLS.json": { + "mode": 292, + "sha256": "72e9e72f1df1aa9f96199e29631c4e84f9eaffe41b0996309f13a349e9f30c00" + }, + "package/docs/SOURCE-READINESS-v3.json": { + "mode": 292, + "sha256": "6f9cace23d2110d285402a8e883f6e5499c052dad6a9bff31a06a2ba4c25dbe5" + }, + "package/provenance/PROPOSAL.json": { + "mode": 292, + "sha256": "9bf3f21b0b2c3db755495e5b6c4ba1b6a76e18f43f8fc1563ae31a808a1ea0ee" + }, + "package/provenance/REVIEW-v3.json": { + "mode": 292, + "sha256": "9f7c7f5abcdb8c8421b82a51020afef3969ad1e2fccb4f1bbcb8484380415555" + }, + "package/provenance/SOURCE-DESIGN.md": { + "mode": 292, + "sha256": "0a12cb7945e4bb772154346c61a202b9f44e7297800306ef9ce113373af77578" + }, + "package/provenance/compare_side_verifier.py": { + "mode": 292, + "sha256": "6e507bb0c7e00d090a60289fddb6c55e90c946d0850c42c3c5e3e15c27604a68" + }, + "package/provenance/native_backend.py": { + "mode": 292, + "sha256": "e473c38245c3668715b5a78dfe980b2fe3ed0d0c9b8c97c666fbae6ecf1fffd5" + }, + "package/provenance/profile_side_verifier.py": { + "mode": 292, + "sha256": "9c994378171c20a91539418d93cb8387e1daa93465d6862beefea90e12999c2a" + }, + "package/reference.py": { + "mode": 292, + "sha256": "38ce1228661156cfbbc908515efd2eee59eff69d887d5e771a83f04ff8812968" + }, + "package/serialization_controls.py": { + "mode": 292, + "sha256": "72951102beea04abeed35011c82f4518e886dff921e0e515025ae0e1e61f9e09" + } + }, + "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", + "schema": "serializer-immutable-stage-v2" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.stderr.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.stdout.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.stdout.txt new file mode 100644 index 0000000000..81d96940f5 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.stdout.txt @@ -0,0 +1 @@ +{"budget_phase_sha256": "b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a", "command": ["/usr/bin/python3.12", "-B", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py", "--output", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science", "--lanes", "serializer-baseline-2048", "--finite-only"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "serializer-baseline-2048", "label": "serializer-baseline-2048", "log_read_chunk_bytes": 65536, "output_cap_observed_at": null, "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "retained_log_bytes_stable": true, "runner_lifetime_max_rss_kib": 18180, "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", "runner_system_seconds": 0.0021350000000000006, "runner_user_seconds": 0.012996999999999995, "runner_wall_seconds": 0.21762533904984593, "sampled_process_group_rss_bytes": 22081536, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.9920211689313874, "stage_sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04", "status": "PASS", "stderr_bytes": 0, "stderr_final_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 79, "stdout_final_bytes": 79, "stdout_sha256": "0bdaf7b0ddda9a07cb13a5a10758487d32ef1abce088719f58880db70af4ebe0", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 20168, "system_seconds": 0.03, "user_seconds": 0.14}, "wall_seconds": 0.2064995289547369} diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.time.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.time.txt new file mode 100644 index 0000000000..60dbf82db7 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-baseline-2048.time.txt @@ -0,0 +1,5 @@ +wall_seconds=0.26 +user_seconds=0.20 +system_seconds=0.04 +max_rss_kib=20168 +exit=0 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.stderr.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.stdout.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.stdout.txt new file mode 100644 index 0000000000..f280037467 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.stdout.txt @@ -0,0 +1 @@ +{"budget_phase_sha256": "b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a", "command": ["/usr/bin/python3.12", "-B", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py", "--output", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science", "--lanes", "serializer-candidate-2048", "--finite-only"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "serializer-candidate-2048", "label": "serializer-candidate-2048", "log_read_chunk_bytes": 65536, "output_cap_observed_at": null, "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "retained_log_bytes_stable": true, "runner_lifetime_max_rss_kib": 18160, "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", "runner_system_seconds": 0.003185, "runner_user_seconds": 0.013538999999999995, "runner_wall_seconds": 0.21725735603831708, "sampled_process_group_rss_bytes": 23973888, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 1.2096465079812333, "stage_sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04", "status": "PASS", "stderr_bytes": 0, "stderr_final_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 80, "stdout_final_bytes": 80, "stdout_sha256": "13841868bf237a386e69f64bbe8061eda663cde3594184e80fe6a874c737f11b", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 22012, "system_seconds": 0.02, "user_seconds": 0.16}, "wall_seconds": 0.2042087479494512} diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.time.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.time.txt new file mode 100644 index 0000000000..aad16c08ea --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-candidate-2048.time.txt @@ -0,0 +1,5 @@ +wall_seconds=0.27 +user_seconds=0.22 +system_seconds=0.03 +max_rss_kib=22012 +exit=0 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.stderr.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.stdout.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.stdout.txt new file mode 100644 index 0000000000..726802f6a7 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.stdout.txt @@ -0,0 +1 @@ +{"budget_phase_sha256": "b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a", "command": ["/usr/bin/python3.12", "-B", "-O", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py", "--output", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science", "--lanes", "serializer-controls", "--finite-only"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "serializer-controls-O", "label": "serializer-controls-O", "log_read_chunk_bytes": 65536, "output_cap_observed_at": null, "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "retained_log_bytes_stable": true, "runner_lifetime_max_rss_kib": 18164, "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", "runner_system_seconds": 0.004125, "runner_user_seconds": 0.015725999999999997, "runner_wall_seconds": 0.5206207169685513, "sampled_process_group_rss_bytes": 25280512, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.4714004519628361, "stage_sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04", "status": "PASS", "stderr_bytes": 0, "stderr_final_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 79, "stdout_final_bytes": 79, "stdout_sha256": "b1e5d8aacb1b6e269fae5a140a4fd53351d84161ee1c5fc0a82a26b8f78795b5", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 23672, "system_seconds": 0.06, "user_seconds": 0.42}, "wall_seconds": 0.5110593680292368} diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.time.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.time.txt new file mode 100644 index 0000000000..b4a59500ba --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-O.time.txt @@ -0,0 +1,5 @@ +wall_seconds=0.56 +user_seconds=0.47 +system_seconds=0.08 +max_rss_kib=23672 +exit=0 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.stderr.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.stderr.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.stdout.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.stdout.txt new file mode 100644 index 0000000000..abb7ba05a9 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.stdout.txt @@ -0,0 +1 @@ +{"budget_phase_sha256": "b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a", "command": ["/usr/bin/python3.12", "-B", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py", "--output", "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science", "--lanes", "serializer-controls", "--finite-only"], "exit": 0, "fractions_sha256": "cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231", "job": "serializer-controls-normal", "label": "serializer-controls-normal", "log_read_chunk_bytes": 65536, "output_cap_observed_at": null, "phase_cap_seconds": 600, "platform": "Linux-7.0.0-38-generic-x86_64-with-glibc2.39", "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]", "retained_log_bytes_stable": true, "runner_lifetime_max_rss_kib": 18160, "runner_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", "runner_system_seconds": 0.007139, "runner_user_seconds": 0.013476999999999996, "runner_wall_seconds": 0.4714004519628361, "sampled_process_group_rss_bytes": 24567808, "source_bytes_and_modes_unchanged": true, "spent_before_seconds": 0.0, "stage_sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04", "status": "PASS", "stderr_bytes": 0, "stderr_final_bytes": 0, "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", "stdout_bytes": 79, "stdout_final_bytes": 79, "stdout_sha256": "1a0ef58a650559d0f38dba77eb5c9dacaeaa4a39405e04a38f3e420367a5220b", "termination": null, "usage": {"exit": 0, "kernel_max_rss_kib": 22592, "system_seconds": 0.1, "user_seconds": 0.3}, "wall_seconds": 0.45877077197656035} diff --git a/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.time.txt b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.time.txt new file mode 100644 index 0000000000..5bd6257d99 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-attempts/serializer-controls-normal.time.txt @@ -0,0 +1,5 @@ +wall_seconds=0.53 +user_seconds=0.36 +system_seconds=0.12 +max_rss_kib=22592 +exit=0 diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-001.json b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-001.json new file mode 100644 index 0000000000..fd6856160f --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-001.json @@ -0,0 +1,54 @@ +{ + "created_utc": "2026-10-31T04:47:43.008087+00:00", + "no_more_automatic_repair_or_retry": true, + "operation": { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-controls-normal", + "serializer-controls-normal" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-normal", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.stdout.txt" + }, + "parent_admitted": true, + "physical_boundary": "OPEN_NOT_ZERO", + "prior_ledger": { + "path": "/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" + }, + "prior_policy_seconds": "66.090533479", + "proposal": { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/OPERATION-PROPOSAL-v1.json", + "sha256": "2a707d3946343121a07150157c120f210afe84329bbe6a6c7b9d61d0719f71ea" + }, + "reservation_seconds": "122.01", + "review": { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json", + "sha256": "6c4ff0861968330694ba1fcb2e9d67feb2d728ba77d17d67affe14f936d65b46" + }, + "schema": "serializer-one-use-repaired-admission-v1", + "single_source_repair_consumed": true +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-002.json b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-002.json new file mode 100644 index 0000000000..4c7cef79b2 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-002.json @@ -0,0 +1,56 @@ +{ + "created_utc": "2026-10-31T04:48:55.941840+00:00", + "governing_independent_review": { + "bytes": 3581, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json", + "sha256": "6c4ff0861968330694ba1fcb2e9d67feb2d728ba77d17d67affe14f936d65b46" + }, + "no_automatic_retry": true, + "operation": { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-controls-O", + "serializer-controls-O" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-O", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.stdout.txt" + }, + "parent_admitted": true, + "physical_boundary": "OPEN_NOT_ZERO", + "prior_ledger": { + "bytes": 2954, + "path": "/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" + }, + "prior_policy_seconds": "68.630533479", + "proposal": { + "bytes": 11225, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/OPERATION-PROPOSAL-v1.json", + "sha256": "2a707d3946343121a07150157c120f210afe84329bbe6a6c7b9d61d0719f71ea" + }, + "reservation_seconds": "122.01", + "schema": "serializer-one-use-admission-v2" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-003.json b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-003.json new file mode 100644 index 0000000000..8cb727b424 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-003.json @@ -0,0 +1,56 @@ +{ + "created_utc": "2026-10-31T04:49:13.821967+00:00", + "governing_independent_review": { + "bytes": 3581, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json", + "sha256": "6c4ff0861968330694ba1fcb2e9d67feb2d728ba77d17d67affe14f936d65b46" + }, + "no_automatic_retry": true, + "operation": { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-baseline-2048", + "serializer-baseline-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-baseline-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.stdout.txt" + }, + "parent_admitted": true, + "physical_boundary": "OPEN_NOT_ZERO", + "prior_ledger": { + "bytes": 2924, + "path": "/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" + }, + "prior_policy_seconds": "71.200533479", + "proposal": { + "bytes": 11225, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/OPERATION-PROPOSAL-v1.json", + "sha256": "2a707d3946343121a07150157c120f210afe84329bbe6a6c7b9d61d0719f71ea" + }, + "reservation_seconds": "122.01", + "schema": "serializer-one-use-admission-v2" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-004.json b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-004.json new file mode 100644 index 0000000000..391f63e465 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/ADMISSION-004.json @@ -0,0 +1,56 @@ +{ + "created_utc": "2026-10-31T04:49:14.315925+00:00", + "governing_independent_review": { + "bytes": 3581, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json", + "sha256": "6c4ff0861968330694ba1fcb2e9d67feb2d728ba77d17d67affe14f936d65b46" + }, + "no_automatic_retry": true, + "operation": { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-candidate-2048", + "serializer-candidate-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-candidate-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.stdout.txt" + }, + "parent_admitted": true, + "physical_boundary": "OPEN_NOT_ZERO", + "prior_ledger": { + "bytes": 2923, + "path": "/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" + }, + "prior_policy_seconds": "73.470533479", + "proposal": { + "bytes": 11225, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/OPERATION-PROPOSAL-v1.json", + "sha256": "2a707d3946343121a07150157c120f210afe84329bbe6a6c7b9d61d0719f71ea" + }, + "reservation_seconds": "122.01", + "schema": "serializer-one-use-admission-v2" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/EXECUTION-PHASE.json b/research/h25-bounded-serializer/validation/execution-v2-control/EXECUTION-PHASE.json new file mode 100644 index 0000000000..7379a9508c --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/EXECUTION-PHASE.json @@ -0,0 +1,7 @@ +{ + "aggregate_cap_seconds": 600, + "maximum_prior_plus_reservation_seconds": "554.130533479", + "maximum_reserved_four_commands_seconds": "488.04", + "prior_policy_seconds": "66.090533479", + "scope": "inner fresh namespace only; parent separately enforces unchanged remaining round" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/LAUNCHER-PINS-v1.json b/research/h25-bounded-serializer/validation/execution-v2-control/LAUNCHER-PINS-v1.json new file mode 100644 index 0000000000..117cad2ba9 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/LAUNCHER-PINS-v1.json @@ -0,0 +1,25 @@ +{ + "files": { + "/usr/bin/env": { + "bytes": 48072, + "realpath": "/usr/bin/env", + "sha256": "886e5fa8be716b03eeda48856e0f04493f2969fc148fb7812594ffac647fa050" + }, + "/usr/bin/flock": { + "bytes": 23024, + "realpath": "/usr/bin/flock", + "sha256": "e619344dc3eec4023498465679262f9ca27d1e8cef9cfc4c1ae72b428577b806" + }, + "/usr/bin/time": { + "bytes": 27160, + "realpath": "/usr/bin/time", + "sha256": "3b11dec50514a8473e9f6efa7a34d584d0657538c09988f61b72d38ad4991a10" + }, + "/usr/bin/timeout": { + "bytes": 39880, + "realpath": "/usr/bin/timeout", + "sha256": "12690a043dfd555a6c14ccc1564f5649c18f1762c0d6ff66729948130898ec52" + } + }, + "scope": "Trusted finite local launcher files; no whole-host attestation" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-001.json b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-001.json new file mode 100644 index 0000000000..b05cd66c5c --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-001.json @@ -0,0 +1,62 @@ +{ + "attempt_policy_seconds": "2.54", + "combined_round_policy_seconds": "68.630533479", + "created_utc": "2026-10-31T04:48:55.938974+00:00", + "evidence": [ + { + "bytes": 81, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.time.txt", + "sha256": "d17b84ec4df4da64eefc34f2ef9a6685b4afd3ff301fa0c8720a83d9526a10f9" + }, + { + "bytes": 2048, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/receipt.json", + "sha256": "4ed9637fb3f45bcbeb85e17f3b3cd6597ebeb389083f9be99f163efa9453b503" + }, + { + "bytes": 0, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 79, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/stdout.txt", + "sha256": "1a0ef58a650559d0f38dba77eb5c9dacaeaa4a39405e04a38f3e420367a5220b" + }, + { + "bytes": 12958, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/adapter-boundary.json", + "sha256": "68c9bfc3e0bd6726b8363e52d7abd780930502979c5f18ed694eda3d9b5184d2" + } + ], + "historical_gap_preserved": true, + "label": "serializer-controls-normal", + "no_automatic_retry": true, + "nominal_admin_seconds": "2", + "operation": 1, + "outer_GNU_time": { + "exit": "0", + "max_rss_kib": "22592", + "system_seconds": "0.12", + "user_seconds": "0.36", + "wall_seconds": "0.53" + }, + "parent_independent_checks": [ + "Exact70orderedcontrols", + "Expectedoptimization0", + "Retainedcontrolcap", + "GuardandcustodyPASS" + ], + "physical_boundary": "OPEN_NOT_ZERO", + "physical_total_seconds": null, + "prior_ledger": { + "bytes": 2093, + "path": "/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" + }, + "prior_policy_seconds": "66.090533479", + "reason": null, + "rounding_margin_seconds": ".01", + "schema": "serializer-operation-accounting-v2", + "status": "PASS" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-002.json b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-002.json new file mode 100644 index 0000000000..04da34f220 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-002.json @@ -0,0 +1,62 @@ +{ + "attempt_policy_seconds": "2.57", + "combined_round_policy_seconds": "71.200533479", + "created_utc": "2026-10-31T04:49:13.820081+00:00", + "evidence": [ + { + "bytes": 81, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.time.txt", + "sha256": "af15e1b7b504c15e84ff4c7819a50cbc9e510d895f53a2e39959223eaf5fb1a8" + }, + { + "bytes": 2059, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/receipt.json", + "sha256": "19d317593dfee82dd4cfc0b44be48cff1d12ef11d793be4e6b3f1db29a3f8ca1" + }, + { + "bytes": 0, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 79, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/stdout.txt", + "sha256": "b1e5d8aacb1b6e269fae5a140a4fd53351d84161ee1c5fc0a82a26b8f78795b5" + }, + { + "bytes": 12958, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/adapter-boundary.json", + "sha256": "5468c842f59a2c041a07f77ae495591753e70da71b1592b1371f38ea898afb4e" + } + ], + "historical_gap_preserved": true, + "label": "serializer-controls-O", + "no_automatic_retry": true, + "nominal_admin_seconds": "2", + "operation": 2, + "outer_GNU_time": { + "exit": "0", + "max_rss_kib": "23672", + "system_seconds": "0.08", + "user_seconds": "0.47", + "wall_seconds": "0.56" + }, + "parent_independent_checks": [ + "Exact70orderedcontrols", + "Expectedoptimization1", + "Retainedcontrolcap", + "GuardandcustodyPASS" + ], + "physical_boundary": "OPEN_NOT_ZERO", + "physical_total_seconds": null, + "prior_ledger": { + "bytes": 2954, + "path": "/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" + }, + "prior_policy_seconds": "68.630533479", + "reason": null, + "rounding_margin_seconds": ".01", + "schema": "serializer-operation-accounting-v2", + "status": "PASS" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-003.json b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-003.json new file mode 100644 index 0000000000..83c685f476 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-003.json @@ -0,0 +1,61 @@ +{ + "attempt_policy_seconds": "2.27", + "combined_round_policy_seconds": "73.470533479", + "created_utc": "2026-10-31T04:49:14.314067+00:00", + "evidence": [ + { + "bytes": 81, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.time.txt", + "sha256": "3f82a34b5950eaf2fb6af42a72503e23925efb30eadece7cf8b948c44ae905a5" + }, + { + "bytes": 2077, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/receipt.json", + "sha256": "39488c2da662e69919acabe2fa0593699baa9fcd248744137c584b0fbdae181d" + }, + { + "bytes": 0, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 79, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/stdout.txt", + "sha256": "0bdaf7b0ddda9a07cb13a5a10758487d32ef1abce088719f58880db70af4ebe0" + }, + { + "bytes": 12157, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science/adapter-boundary.json", + "sha256": "3285fe2ce9723396d6169138a4ecc2c304274856d4b4667ff24b6aa7f0e6eaf6" + } + ], + "historical_gap_preserved": true, + "label": "serializer-baseline-2048", + "no_automatic_retry": true, + "nominal_admin_seconds": "2", + "operation": 3, + "outer_GNU_time": { + "exit": "0", + "max_rss_kib": "20168", + "system_seconds": "0.04", + "user_seconds": "0.20", + "wall_seconds": "0.26" + }, + "parent_independent_checks": [ + "Threeactualartifactreadbacks", + "Declaredfixtureandmode", + "GuardandcustodyPASS" + ], + "physical_boundary": "OPEN_NOT_ZERO", + "physical_total_seconds": null, + "prior_ledger": { + "bytes": 2924, + "path": "/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" + }, + "prior_policy_seconds": "71.200533479", + "reason": null, + "rounding_margin_seconds": ".01", + "schema": "serializer-operation-accounting-v2", + "status": "PASS" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-004.json b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-004.json new file mode 100644 index 0000000000..a2821ca0e4 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/LEDGER-004.json @@ -0,0 +1,62 @@ +{ + "attempt_policy_seconds": "2.28", + "combined_round_policy_seconds": "75.750533479", + "created_utc": "2026-10-31T04:49:14.848060+00:00", + "evidence": [ + { + "bytes": 81, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.time.txt", + "sha256": "9b4271ac7ac4f1a46d823f925c8ae67f8bbd3782edee9d6c0ff428c5bcf90f63" + }, + { + "bytes": 2068, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/receipt.json", + "sha256": "e1ab7b9fba3f60b9ec2301bfc0d17fab99edceaab594d80aeb9da06ecbd917a9" + }, + { + "bytes": 0, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + { + "bytes": 80, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/stdout.txt", + "sha256": "13841868bf237a386e69f64bbe8061eda663cde3594184e80fe6a874c737f11b" + }, + { + "bytes": 12670, + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/adapter-boundary.json", + "sha256": "27799c52c8a697648e2a8fbe2911e008e9fd863422b1c2c09b240e2491f4e840" + } + ], + "historical_gap_preserved": true, + "label": "serializer-candidate-2048", + "no_automatic_retry": true, + "nominal_admin_seconds": "2", + "operation": 4, + "outer_GNU_time": { + "exit": "0", + "max_rss_kib": "22012", + "system_seconds": "0.03", + "user_seconds": "0.22", + "wall_seconds": "0.27" + }, + "parent_independent_checks": [ + "Threeactualartifactreadbacks", + "Declaredfixtureandmode", + "GuardandcustodyPASS", + "Independentcompletefiniteartifactbyteequality" + ], + "physical_boundary": "OPEN_NOT_ZERO", + "physical_total_seconds": null, + "prior_ledger": { + "bytes": 2923, + "path": "/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" + }, + "prior_policy_seconds": "73.470533479", + "reason": null, + "rounding_margin_seconds": ".01", + "schema": "serializer-operation-accounting-v2", + "status": "PASS" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-control/OPERATION-PROPOSAL-v1.json b/research/h25-bounded-serializer/validation/execution-v2-control/OPERATION-PROPOSAL-v1.json new file mode 100644 index 0000000000..e51010c9f3 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-control/OPERATION-PROPOSAL-v1.json @@ -0,0 +1,177 @@ +{ + "created_utc": "2026-10-31T04:43:12.084943+00:00", + "execution_admission": false, + "failure_rule": "Any nonzero, timeout, bad/unclosed receipt, changed custody or independent rejection stops dispatch. Retain and charge attempts. No retry/reroll. No cleanup inference after interruption.", + "independent_readback": "Parent checks exact70 ordered names/mode, baseline/candidate complete artifact bytes/hashes/counts, guard logs/custody/cost retained metadata without target imports.", + "launchers": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LAUNCHER-PINS-v1.json", + "sha256": "51a09ea4c1fa9b46c3767b65ca93663584b6cb5ad8266a891da6a8ff98ead4da" + }, + "operations": [ + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-controls-normal", + "serializer-controls-normal" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-normal", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-controls-O", + "serializer-controls-O" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-controls-O", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-baseline-2048", + "serializer-baseline-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-baseline-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.stdout.txt" + }, + { + "argv": [ + "/usr/bin/env", + "PYTHONNOUSERSITE=1", + "PYTHONSAFEPATH=1", + "/usr/bin/flock", + "-n", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-bookkeeping-swarm-20261028/runtime/science.lock", + "/usr/bin/time", + "-f", + "wall_seconds=%e\nuser_seconds=%U\nsystem_seconds=%S\nmax_rss_kib=%M\nexit=%x", + "-o", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.time.txt", + "/usr/bin/timeout", + "--signal=INT", + "--kill-after=3s", + "117s", + "/usr/bin/python3.12", + "-B", + "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "serializer-v2", + "serializer-candidate-2048", + "serializer-candidate-2048" + ], + "cwd": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453", + "label": "serializer-candidate-2048", + "per_command_policy_reservation_seconds": "122.01", + "run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048", + "status": "NOT_EXECUTED", + "stderr": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.stderr.txt", + "stdout": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.stdout.txt" + } + ], + "outer_timeout": "SIGINT at117s reaches Python guard finally; SIGKILL fallback3s. Trusted responsive local filesystem, bounded purePython/stdlib finite fixture only; arbitrary hostile runtime and uninterruptible IO not attested.", + "phase": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/EXECUTION-PHASE.json", + "sha256": "b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a" + }, + "predecessor": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/OPERATION-PROPOSAL-v1.json", + "sha256": "a332a9e94833321960a2ad7aa79cafe0d16e6b26f1028ce6478dd47a7c24edb5" + }, + "predecessor_failed_proposal": { + "path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/OPERATION-PROPOSAL-v2.json", + "sha256": "788cd8fbb6c0c9efc5402990fc6c58d17bf761d6d337c450d15a4f6cdc96e8ac" + }, + "prior_actual_ledger": { + "path": "/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" + }, + "reservation": { + "initial_cap_seconds": 600, + "max_total_policy_seconds": "554.130533479", + "no_new_budget": true, + "operations": 4, + "per_command_seconds": "122.01", + "prior_policy_seconds": "66.090533479", + "total_cap_seconds": 2400 + }, + "runner": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/run_guarded.py", + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + }, + "schema": "serializer-parent-corrected-four-operation-proposal-v1", + "single_source_repair": "runtime manifest adds omitted sitecustomize path; actual adapter/JOBS/serializer/control source unchanged; v1attemptandremainingadmissionsstopped", + "stage": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/STAGE.json", + "sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04" + }, + "whole_physical_boundary": "OPEN_NOT_ZERO; nominal2secadmin+.01GNUrounding perattempt; external metadata/readback/publication residual unknown" +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-serializer-baseline-2048-raw.json b/research/h25-bounded-serializer/validation/execution-v2-serializer-baseline-2048-raw.json new file mode 100644 index 0000000000..b73bb451dc --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-serializer-baseline-2048-raw.json @@ -0,0 +1,68 @@ +{ + "file_count": 10, + "files": [ + { + "bytes": 1087, + "path": "START.json", + "sha256": "9e5d7e3c5a96596b9bf5b20468eca5cfc77d2b34a324c479969cc0f967e91d5d", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science\",\n \"--lanes\",\n \"serializer-baseline-2048\",\n \"--finite-only\"\n ],\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-baseline-2048\",\n \"label\": \"serializer-baseline-2048\",\n \"phase_cap_seconds\": 600,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"spent_before_seconds\": 0.9920211689313874,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\"\n}\n" + }, + { + "bytes": 2077, + "path": "receipt.json", + "sha256": "39488c2da662e69919acabe2fa0593699baa9fcd248744137c584b0fbdae181d", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science\",\n \"--lanes\",\n \"serializer-baseline-2048\",\n \"--finite-only\"\n ],\n \"exit\": 0,\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-baseline-2048\",\n \"label\": \"serializer-baseline-2048\",\n \"log_read_chunk_bytes\": 65536,\n \"output_cap_observed_at\": null,\n \"phase_cap_seconds\": 600,\n \"platform\": \"Linux-7.0.0-38-generic-x86_64-with-glibc2.39\",\n \"python\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"retained_log_bytes_stable\": true,\n \"runner_lifetime_max_rss_kib\": 18180,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"runner_system_seconds\": 0.0021350000000000006,\n \"runner_user_seconds\": 0.012996999999999995,\n \"runner_wall_seconds\": 0.21762533904984593,\n \"sampled_process_group_rss_bytes\": 22081536,\n \"source_bytes_and_modes_unchanged\": true,\n \"spent_before_seconds\": 0.9920211689313874,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\",\n \"status\": \"PASS\",\n \"stderr_bytes\": 0,\n \"stderr_final_bytes\": 0,\n \"stderr_sha256\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\n \"stdout_bytes\": 79,\n \"stdout_final_bytes\": 79,\n \"stdout_sha256\": \"0bdaf7b0ddda9a07cb13a5a10758487d32ef1abce088719f58880db70af4ebe0\",\n \"termination\": null,\n \"usage\": {\n \"exit\": 0,\n \"kernel_max_rss_kib\": 20168,\n \"system_seconds\": 0.03,\n \"user_seconds\": 0.14\n },\n \"wall_seconds\": 0.2064995289547369\n}\n" + }, + { + "bytes": 12157, + "path": "science/adapter-boundary.json", + "sha256": "3285fe2ce9723396d6169138a4ecc2c304274856d4b4667ff24b6aa7f0e6eaf6", + "utf8": "{\n \"after\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__future__\": \"/usr/lib/python3.12/__future__.py\",\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"component_consumer\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/component_consumer.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reference\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/reference.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"before\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"component_status\": \"FINITE_SERIALIZER_COMPONENT_RETURNED\",\n \"dont_write_bytecode\": true,\n \"environment\": {\n \"LC_ALL\": \"C.UTF-8\",\n \"PYTHONDONTWRITEBYTECODE\": \"1\",\n \"PYTHONHASHSEED\": \"0\",\n \"PYTHONNOUSERSITE\": \"1\",\n \"PYTHONSAFEPATH\": \"1\",\n \"TZ\": \"UTC\"\n },\n \"executable\": \"/usr/bin/python3.12\",\n \"executable_realpath\": \"/usr/bin/python3.12\",\n \"fixture_rows\": 2048,\n \"mode\": \"baseline\",\n \"no_user_site\": 1,\n \"optimization\": 0,\n \"python_version\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"safe_path\": true,\n \"scope\": \"Supported finite serializer host only; no full H25 custody/performance claim\",\n \"status\": \"FINITE_COMPONENT_RETURNED\"\n}\n" + }, + { + "bytes": 1128, + "path": "science/component/component-receipt.json", + "sha256": "b5d4276150930e7d428893af1d6017d8f3acbeb9408e4e9a4bc03e6dc21e82eb", + "utf8": "{\n \"candidate_operation\": null,\n \"files\": {\n \"rank-trace.json\": {\n \"bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"bytes\": 9366,\n \"sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\"\n }\n },\n \"fixture_rows\": 2048,\n \"mode\": \"baseline\",\n \"optimization\": 0,\n \"scientific_receipt\": {\n \"exact_witness_sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\",\n \"rank_call_count\": 3,\n \"rank_distinct_matrix_count\": 2,\n \"rank_trace_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"result_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"serialized_bytes\": {\n \"rank_trace\": 29,\n \"result\": 22,\n \"witness\": 9366\n }\n },\n \"scope\": \"Finite serializer fixture only; no complete H25 or performance qualification\",\n \"status\": \"FINITE_SERIALIZER_COMPONENT_RETURNED\"\n}\n" + }, + { + "bytes": 29, + "path": "science/component/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 9366, + "path": "science/component/witness.json", + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047]}" + }, + { + "bytes": 0, + "path": "stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 79, + "path": "stdout.txt", + "sha256": "0bdaf7b0ddda9a07cb13a5a10758487d32ef1abce088719f58880db70af4ebe0", + "utf8": "{\"mode\": \"baseline\", \"optimization\": 0, \"status\": \"FINITE_COMPONENT_RETURNED\"}\n" + }, + { + "bytes": 80, + "path": "usage.json", + "sha256": "b160fa36bdc1ca882c29473d007d0ae35e604febbf3a3d61f1af7bb126880122", + "utf8": "{\"user_seconds\":0.14,\"system_seconds\":0.03,\"kernel_max_rss_kib\":20168,\"exit\":0}\n" + } + ], + "original_run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048", + "schema": "verbatim-finite-run-bundle-v1", + "total_bytes": 26025 +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-serializer-candidate-2048-raw.json b/research/h25-bounded-serializer/validation/execution-v2-serializer-candidate-2048-raw.json new file mode 100644 index 0000000000..5656e59d66 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-serializer-candidate-2048-raw.json @@ -0,0 +1,68 @@ +{ + "file_count": 10, + "files": [ + { + "bytes": 1091, + "path": "START.json", + "sha256": "3e446925b67a8768fad7c93c47d46ea8090982e62fd687cc20be6f6d0915eca3", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science\",\n \"--lanes\",\n \"serializer-candidate-2048\",\n \"--finite-only\"\n ],\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-candidate-2048\",\n \"label\": \"serializer-candidate-2048\",\n \"phase_cap_seconds\": 600,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"spent_before_seconds\": 1.2096465079812333,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\"\n}\n" + }, + { + "bytes": 2068, + "path": "receipt.json", + "sha256": "e1ab7b9fba3f60b9ec2301bfc0d17fab99edceaab594d80aeb9da06ecbd917a9", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science\",\n \"--lanes\",\n \"serializer-candidate-2048\",\n \"--finite-only\"\n ],\n \"exit\": 0,\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-candidate-2048\",\n \"label\": \"serializer-candidate-2048\",\n \"log_read_chunk_bytes\": 65536,\n \"output_cap_observed_at\": null,\n \"phase_cap_seconds\": 600,\n \"platform\": \"Linux-7.0.0-38-generic-x86_64-with-glibc2.39\",\n \"python\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"retained_log_bytes_stable\": true,\n \"runner_lifetime_max_rss_kib\": 18160,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"runner_system_seconds\": 0.003185,\n \"runner_user_seconds\": 0.013538999999999995,\n \"runner_wall_seconds\": 0.21725735603831708,\n \"sampled_process_group_rss_bytes\": 23973888,\n \"source_bytes_and_modes_unchanged\": true,\n \"spent_before_seconds\": 1.2096465079812333,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\",\n \"status\": \"PASS\",\n \"stderr_bytes\": 0,\n \"stderr_final_bytes\": 0,\n \"stderr_sha256\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\n \"stdout_bytes\": 80,\n \"stdout_final_bytes\": 80,\n \"stdout_sha256\": \"13841868bf237a386e69f64bbe8061eda663cde3594184e80fe6a874c737f11b\",\n \"termination\": null,\n \"usage\": {\n \"exit\": 0,\n \"kernel_max_rss_kib\": 22012,\n \"system_seconds\": 0.02,\n \"user_seconds\": 0.16\n },\n \"wall_seconds\": 0.2042087479494512\n}\n" + }, + { + "bytes": 12670, + "path": "science/adapter-boundary.json", + "sha256": "27799c52c8a697648e2a8fbe2911e008e9fd863422b1c2c09b240e2491f4e840", + "utf8": "{\n \"after\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__future__\": \"/usr/lib/python3.12/__future__.py\",\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bisect\": \"/usr/lib/python3.12/bisect.py\",\n \"bounded_serialization\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/bounded_serialization.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"component_consumer\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/component_consumer.py\",\n \"contextlib\": \"/usr/lib/python3.12/contextlib.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"random\": \"/usr/lib/python3.12/random.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reference\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/reference.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"tempfile\": \"/usr/lib/python3.12/tempfile.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"weakref\": \"/usr/lib/python3.12/weakref.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"before\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"component_status\": \"FINITE_SERIALIZER_COMPONENT_RETURNED\",\n \"dont_write_bytecode\": true,\n \"environment\": {\n \"LC_ALL\": \"C.UTF-8\",\n \"PYTHONDONTWRITEBYTECODE\": \"1\",\n \"PYTHONHASHSEED\": \"0\",\n \"PYTHONNOUSERSITE\": \"1\",\n \"PYTHONSAFEPATH\": \"1\",\n \"TZ\": \"UTC\"\n },\n \"executable\": \"/usr/bin/python3.12\",\n \"executable_realpath\": \"/usr/bin/python3.12\",\n \"fixture_rows\": 2048,\n \"mode\": \"candidate\",\n \"no_user_site\": 1,\n \"optimization\": 0,\n \"python_version\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"safe_path\": true,\n \"scope\": \"Supported finite serializer host only; no full H25 custody/performance claim\",\n \"status\": \"FINITE_COMPONENT_RETURNED\"\n}\n" + }, + { + "bytes": 2768, + "path": "science/component/component-receipt.json", + "sha256": "06900868428688a7d0b8319a13fbe33c9f1348d2ba5bd0c3a2342c4eb3a17e3c", + "utf8": "{\n \"candidate_operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 11,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 9366,\n \"copy_read_bytes\": 9366,\n \"copy_sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\",\n \"copy_write_bytes\": 9366,\n \"hashed_bytes\": 9366,\n \"sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\"\n }\n },\n \"largest_batch_bytes\": 5121,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/component/.serialization-kfsp4n5e\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"bytes\": 9366,\n \"sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\"\n }\n },\n \"fixture_rows\": 2048,\n \"mode\": \"candidate\",\n \"optimization\": 0,\n \"scientific_receipt\": {\n \"exact_witness_sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\",\n \"rank_call_count\": 3,\n \"rank_distinct_matrix_count\": 2,\n \"rank_trace_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"result_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"serialized_bytes\": {\n \"rank_trace\": 29,\n \"result\": 22,\n \"witness\": 9366\n }\n },\n \"scope\": \"Finite serializer fixture only; no complete H25 or performance qualification\",\n \"status\": \"FINITE_SERIALIZER_COMPONENT_RETURNED\"\n}\n" + }, + { + "bytes": 29, + "path": "science/component/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 9366, + "path": "science/component/witness.json", + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047]}" + }, + { + "bytes": 0, + "path": "stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 80, + "path": "stdout.txt", + "sha256": "13841868bf237a386e69f64bbe8061eda663cde3594184e80fe6a874c737f11b", + "utf8": "{\"mode\": \"candidate\", \"optimization\": 0, \"status\": \"FINITE_COMPONENT_RETURNED\"}\n" + }, + { + "bytes": 80, + "path": "usage.json", + "sha256": "6e954dda53da4a4d503f2c1b44a85b270ffb6873bded00b0bbdcd215128400ee", + "utf8": "{\"user_seconds\":0.16,\"system_seconds\":0.02,\"kernel_max_rss_kib\":22012,\"exit\":0}\n" + } + ], + "original_run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048", + "schema": "verbatim-finite-run-bundle-v1", + "total_bytes": 28174 +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-serializer-controls-O-raw.json b/research/h25-bounded-serializer/validation/execution-v2-serializer-controls-O-raw.json new file mode 100644 index 0000000000..4d4ba54a53 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-serializer-controls-O-raw.json @@ -0,0 +1,1808 @@ +{ + "file_count": 300, + "files": [ + { + "bytes": 1083, + "path": "START.json", + "sha256": "b385ef98b6ecf7616f7c608dda33b18717780a6c205cb20926fa259a088f784f", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"-O\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science\",\n \"--lanes\",\n \"serializer-controls\",\n \"--finite-only\"\n ],\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-controls-O\",\n \"label\": \"serializer-controls-O\",\n \"phase_cap_seconds\": 600,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"spent_before_seconds\": 0.4714004519628361,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\"\n}\n" + }, + { + "bytes": 2059, + "path": "receipt.json", + "sha256": "19d317593dfee82dd4cfc0b44be48cff1d12ef11d793be4e6b3f1db29a3f8ca1", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"-O\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science\",\n \"--lanes\",\n \"serializer-controls\",\n \"--finite-only\"\n ],\n \"exit\": 0,\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-controls-O\",\n \"label\": \"serializer-controls-O\",\n \"log_read_chunk_bytes\": 65536,\n \"output_cap_observed_at\": null,\n \"phase_cap_seconds\": 600,\n \"platform\": \"Linux-7.0.0-38-generic-x86_64-with-glibc2.39\",\n \"python\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"retained_log_bytes_stable\": true,\n \"runner_lifetime_max_rss_kib\": 18164,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"runner_system_seconds\": 0.004125,\n \"runner_user_seconds\": 0.015725999999999997,\n \"runner_wall_seconds\": 0.5206207169685513,\n \"sampled_process_group_rss_bytes\": 25280512,\n \"source_bytes_and_modes_unchanged\": true,\n \"spent_before_seconds\": 0.4714004519628361,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\",\n \"status\": \"PASS\",\n \"stderr_bytes\": 0,\n \"stderr_final_bytes\": 0,\n \"stderr_sha256\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\n \"stdout_bytes\": 79,\n \"stdout_final_bytes\": 79,\n \"stdout_sha256\": \"b1e5d8aacb1b6e269fae5a140a4fd53351d84161ee1c5fc0a82a26b8f78795b5\",\n \"termination\": null,\n \"usage\": {\n \"exit\": 0,\n \"kernel_max_rss_kib\": 23672,\n \"system_seconds\": 0.06,\n \"user_seconds\": 0.42\n },\n \"wall_seconds\": 0.5110593680292368\n}\n" + }, + { + "bytes": 12958, + "path": "science/adapter-boundary.json", + "sha256": "5468c842f59a2c041a07f77ae495591753e70da71b1592b1371f38ea898afb4e", + "utf8": "{\n \"after\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__future__\": \"/usr/lib/python3.12/__future__.py\",\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bisect\": \"/usr/lib/python3.12/bisect.py\",\n \"bounded_serialization\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/bounded_serialization.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"component_consumer\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/component_consumer.py\",\n \"contextlib\": \"/usr/lib/python3.12/contextlib.py\",\n \"copy\": \"/usr/lib/python3.12/copy.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"random\": \"/usr/lib/python3.12/random.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reference\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/reference.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"serialization_controls\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/serialization_controls.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"tempfile\": \"/usr/lib/python3.12/tempfile.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"weakref\": \"/usr/lib/python3.12/weakref.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"before\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"component_status\": \"SERIALIZATION_FINITE_PASS\",\n \"dont_write_bytecode\": true,\n \"environment\": {\n \"LC_ALL\": \"C.UTF-8\",\n \"PYTHONDONTWRITEBYTECODE\": \"1\",\n \"PYTHONHASHSEED\": \"0\",\n \"PYTHONNOUSERSITE\": \"1\",\n \"PYTHONSAFEPATH\": \"1\",\n \"TZ\": \"UTC\"\n },\n \"executable\": \"/usr/bin/python3.12\",\n \"executable_realpath\": \"/usr/bin/python3.12\",\n \"fixture_rows\": null,\n \"mode\": \"controls\",\n \"no_user_site\": 1,\n \"optimization\": 1,\n \"python_version\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"safe_path\": true,\n \"scope\": \"Supported finite serializer host only; no full H25 custody/performance claim\",\n \"status\": \"FINITE_COMPONENT_RETURNED\"\n}\n" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-169/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-169/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 408, + "path": "science/component/byte-bound-169/candidate/witness.json", + "sha256": "15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-169/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-169/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 408, + "path": "science/component/byte-bound-169/original/witness.json", + "sha256": "15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-170/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-170/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 409, + "path": "science/component/byte-bound-170/candidate/witness.json", + "sha256": "1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-170/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-170/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 409, + "path": "science/component/byte-bound-170/original/witness.json", + "sha256": "1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-171/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-171/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 410, + "path": "science/component/byte-bound-171/candidate/witness.json", + "sha256": "1c476c4ab260493228029992b948640ee4938756f14f6c9431ff7cb14b8ac89b", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-171/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-171/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 410, + "path": "science/component/byte-bound-171/original/witness.json", + "sha256": "1c476c4ab260493228029992b948640ee4938756f14f6c9431ff7cb14b8ac89b", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-dict/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-dict/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/callback-dict/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-dict/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-dict/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/callback-dict/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-list/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-list/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 241, + "path": "science/component/callback-list/candidate/witness.json", + "sha256": "2c5a0741bc48d9addda2820488ce0470d7a434cb6b5cf3c41e4f271fbdd4e50a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"in\",\"x\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-list/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-list/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 241, + "path": "science/component/callback-list/original/witness.json", + "sha256": "2c5a0741bc48d9addda2820488ce0470d7a434cb6b5cf3c41e4f271fbdd4e50a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"in\",\"x\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1453, + "path": "science/component/cleanup-rmdir-error/.serialization-7d3n4v0e/failure.json", + "sha256": "cbc1ae804a517a2248504297584327581cd0ac5a0f19cf90b3fdb9fa85e16ab9", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[\"result.json\",\"witness.json\",\"rank-trace.json\"],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":null,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":null,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":null,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"cleanup\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/cleanup-rmdir-error/.serialization-7d3n4v0e\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/cleanup-rmdir-error/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/cleanup-rmdir-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/cleanup-rmdir-error/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1418, + "path": "science/component/cleanup-unlink-error/.serialization-azld61e2/failure.json", + "sha256": "8a2205cd79a89bbb09443818d1d40873bbc20909cbf213509c32719706d636b8", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[\"result.json\"],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":null,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"cleanup\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/cleanup-unlink-error/.serialization-azld61e2\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/cleanup-unlink-error/.serialization-azld61e2/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 242, + "path": "science/component/cleanup-unlink-error/.serialization-azld61e2/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/cleanup-unlink-error/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/cleanup-unlink-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/cleanup-unlink-error/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 167, + "path": "science/component/component-control-acceptance.json", + "sha256": "3a0e95fe2070e2be534f9e77280f792e845f47cbdd470adf6dc72fd7ede6925f", + "utf8": "{\n \"case_count\": 70,\n \"optimization\": 1,\n \"scope\": \"Finite component only; requires independent parent validation\",\n \"status\": \"COMPONENT_CONTROL_ORDER_CHECKED\"\n}\n" + }, + { + "bytes": 88571, + "path": "science/component/controls.json", + "sha256": "ea43c633a1aade49791d56b33dedba70ed85dcaf42a8f58996ef9e215503ef3c", + "utf8": "{\n \"case_count\": 70,\n \"cases\": [\n {\n \"case\": \"ordinary\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/ordinary/candidate/.serialization-98ronwl1\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"empty\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 0,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 2,\n \"copy_read_bytes\": 2,\n \"copy_sha256\": \"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945\",\n \"copy_write_bytes\": 2,\n \"hashed_bytes\": 2,\n \"sha256\": \"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 126,\n \"copy_read_bytes\": 126,\n \"copy_sha256\": \"34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405\",\n \"copy_write_bytes\": 126,\n \"hashed_bytes\": 126,\n \"sha256\": \"34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405\"\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/empty/candidate/.serialization-w3uw29ct\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 238,\n \"copy_read_bytes\": 238,\n \"copy_sha256\": \"02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443\",\n \"copy_write_bytes\": 238,\n \"hashed_bytes\": 238,\n \"sha256\": \"02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/rows-1/candidate/.serialization-ovn1iqkg\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1023\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 4241,\n \"copy_read_bytes\": 4241,\n \"copy_sha256\": \"d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143\",\n \"copy_write_bytes\": 4241,\n \"hashed_bytes\": 4241,\n \"sha256\": \"d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143\"\n }\n },\n \"largest_batch_bytes\": 4006,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/rows-1023/candidate/.serialization-2huu_4jf\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1024\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 4246,\n \"copy_read_bytes\": 4246,\n \"copy_sha256\": \"356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283\",\n \"copy_write_bytes\": 4246,\n \"hashed_bytes\": 4246,\n \"sha256\": \"356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283\"\n }\n },\n \"largest_batch_bytes\": 4011,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/rows-1024/candidate/.serialization-vt8r03t2\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1025\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 11,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 4251,\n \"copy_read_bytes\": 4251,\n \"copy_sha256\": \"cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4\",\n \"copy_write_bytes\": 4251,\n \"hashed_bytes\": 4251,\n \"sha256\": \"cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4\"\n }\n },\n \"largest_batch_bytes\": 4011,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/rows-1025/candidate/.serialization-wd5xo23l\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-2048\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 11,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 9366,\n \"copy_read_bytes\": 9366,\n \"copy_sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\",\n \"copy_write_bytes\": 9366,\n \"hashed_bytes\": 9366,\n \"sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\"\n }\n },\n \"largest_batch_bytes\": 5121,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/rows-2048/candidate/.serialization-o776psvm\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"byte-bound-169\",\n \"operation\": {\n \"batch_bytes_limit\": 2045,\n \"batch_count\": 11,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 127,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 408,\n \"copy_read_bytes\": 408,\n \"copy_sha256\": \"15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23\",\n \"copy_write_bytes\": 408,\n \"hashed_bytes\": 408,\n \"sha256\": \"15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23\"\n }\n },\n \"largest_batch_bytes\": 173,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/byte-bound-169/candidate/.serialization-rquauopw\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"byte-bound-170\",\n \"operation\": {\n \"batch_bytes_limit\": 2045,\n \"batch_count\": 11,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 127,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 409,\n \"copy_read_bytes\": 409,\n \"copy_sha256\": \"1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e\",\n \"copy_write_bytes\": 409,\n \"hashed_bytes\": 409,\n \"sha256\": \"1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e\"\n }\n },\n \"largest_batch_bytes\": 174,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/byte-bound-170/candidate/.serialization-gg9o1arm\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"byte-bound-171\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"scalars-unicode-wide\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 1132,\n \"copy_read_bytes\": 1132,\n \"copy_sha256\": \"413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918\",\n \"copy_write_bytes\": 1132,\n \"hashed_bytes\": 1132,\n \"sha256\": \"413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918\"\n }\n },\n \"largest_batch_bytes\": 798,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/scalars-unicode-wide/candidate/.serialization-4stgsde6\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"wide-unlimited\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 12281,\n \"copy_read_bytes\": 12281,\n \"copy_sha256\": \"4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c\",\n \"copy_write_bytes\": 12281,\n \"hashed_bytes\": 12281,\n \"sha256\": \"4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c\"\n }\n },\n \"largest_batch_bytes\": 12046,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/wide-unlimited/candidate/.serialization-osb1fpgg\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"wide-digit-error\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 8,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Exceeds the limit (640 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit\",\n \"type\": \"ValueError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 235,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 235,\n \"retained_stage_stat_bytes\": 235\n }\n },\n \"largest_batch_bytes\": 27,\n \"phase\": \"stage:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/wide-digit-error/candidate/.serialization-tuz_nwbf\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"interned-rank-rows\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 37,\n \"copy_read_bytes\": 37,\n \"copy_sha256\": \"28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2\",\n \"copy_write_bytes\": 37,\n \"hashed_bytes\": 37,\n \"sha256\": \"28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 37,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/interned-rank-rows/candidate/.serialization-1bb67kzz\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"depth-30\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 294,\n \"copy_read_bytes\": 294,\n \"copy_sha256\": \"83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679\",\n \"copy_write_bytes\": 294,\n \"hashed_bytes\": 294,\n \"sha256\": \"83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679\"\n }\n },\n \"largest_batch_bytes\": 63,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/depth-30/candidate/.serialization-elfi8o0d\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"depth-33\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"circular\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"callback-list\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"callback-dict\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"callback-error\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"int-subclass\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"unsupported-object\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"malformed-result\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"malformed-witness\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"malformed-rank\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"nonstring-supported-keys\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"expected-result_sha256\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-result_sha256/candidate/.serialization-2p679p7w\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-exact_witness_sha256\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-exact_witness_sha256/candidate/.serialization-2ww_z9xd\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-rank_trace_sha256\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-rank_trace_sha256/candidate/.serialization-4hh874g9\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-rank_call_count\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-rank_call_count/candidate/.serialization-mdv34g20\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-rank_distinct_matrix_count\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-rank_distinct_matrix_count/candidate/.serialization-bg1c06gs\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"failure-stage_create\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {},\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage_create\",\n \"stage\": null,\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_open\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 0,\n \"retained_stage_stat_bytes\": null\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_open/.serialization-g0mwmxvz\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_write\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_write/.serialization-gqbb5nwe\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_flush\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_flush/.serialization-xo6incq2\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_after_close\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_after_close/.serialization-6bmn05y_\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_hash\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 0,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_hash/.serialization-fygyqwbq\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_open-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_open-result.json/.serialization-l3ikcnim\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_write-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_write-result.json/.serialization-asmbg9jq\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_flush-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_flush-result.json/.serialization-6d30yxhn\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_after_close-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_after_close-result.json/.serialization-7b9y7ych\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_open-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_open-witness.json/.serialization-dco0pyd4\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_write-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_write-witness.json/.serialization-mnpfz2le\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_flush-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_flush-witness.json/.serialization-b1pj4pha\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_after_close-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_after_close-witness.json/.serialization-aee8bgsc\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_open-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_open-rank-trace.json/.serialization-19wg121c\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_write-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_write-rank-trace.json/.serialization-aekvlc4t\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_flush-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_flush-rank-trace.json/.serialization-8mn1zyq9\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_after_close-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_after_close-rank-trace.json/.serialization-c0qrmz9m\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"short-final-0\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Short final write; no retry\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/short-final-0/.serialization-epxr7n1y\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"Short final write; no retry\"\n ]\n },\n {\n \"case\": \"short-final-1\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Short final write; no retry\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/short-final-1/.serialization-nwk_ylfd\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"Short final write; no retry\"\n ]\n },\n {\n \"case\": \"copy-corrupt-content\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Staged copy digest or byte count changed\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/copy-corrupt-content/.serialization-c9h3pjr0\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Staged copy digest or byte count changed\"\n ]\n },\n {\n \"case\": \"stage-mutated-size\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Staged artifact changed before copy\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 243,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/stage-mutated-size/.serialization-mstwyeu9\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Staged artifact changed before copy\"\n ]\n },\n {\n \"case\": \"copy-read-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/copy-read-error/.serialization-2_n44ktm\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"copy-hash-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/copy-hash-error/.serialization-czhivgso\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"cleanup-unlink-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\"\n ],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"cleanup\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/cleanup-unlink-error/.serialization-azld61e2\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"cleanup-rmdir-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\"\n ],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"cleanup\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/cleanup-rmdir-error/.serialization-7d3n4v0e\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"primary-plus-close-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"close_errors\": [\n {\n \"phase\": \"stage\",\n \"type\": \"OSError\"\n }\n ],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"primary write failure\",\n \"type\": \"ValueError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/primary-plus-close-error/.serialization-v6bwrsxw\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"ValueError\",\n \"primary write failure\"\n ]\n },\n {\n \"case\": \"primary-plus-manifest-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"primary write failure\",\n \"type\": \"ValueError\"\n },\n \"failure_manifest_error_type\": \"OSError\",\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/primary-plus-manifest-error/.serialization-v9f52f28\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"ValueError\",\n \"primary write failure\"\n ]\n },\n {\n \"case\": \"drift-reference_global\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Serializer effective global/builtin changed: canonical\"\n ]\n },\n {\n \"case\": \"drift-json_default\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON encoder binding changed: default\"\n ]\n },\n {\n \"case\": \"drift-expected_value\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Expected serializer receipt changed\"\n ]\n },\n {\n \"case\": \"drift-effective_builtin\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Serializer effective global/builtin changed: len\"\n ]\n },\n {\n \"case\": \"drift-json_global_shadow\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Serializer effective global/builtin changed: str\"\n ]\n },\n {\n \"case\": \"drift-keyword_default\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON keyword default changed\"\n ]\n },\n {\n \"case\": \"exit-json-drift\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"JSON encoder binding changed: default\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"precleanup_freshness\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/exit-json-drift/.serialization-rfuhvwa9\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON encoder binding changed: default\"\n ]\n },\n {\n \"case\": \"fallback-exit-json-drift\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON encoder binding changed: default\"\n ]\n },\n {\n \"case\": \"existing-finals\",\n \"outcome\": \"return\"\n },\n {\n \"case\": \"state-mutation-between-writes\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Complete output, ordered witness, or rank trace changed from the frozen profile\"\n ]\n },\n {\n \"case\": \"path-subclass-fallback\",\n \"outcome\": \"return\"\n }\n ],\n \"optimization\": 1,\n \"retained_byte_cap\": 16777216,\n \"retained_bytes\": 132297,\n \"scope\": \"Finite exact-schema/unsupported/reference/regular-file controls; no full caller or performance claim\",\n \"status\": \"SERIALIZATION_FINITE_PASS\"\n}\n" + }, + { + "bytes": 1275, + "path": "science/component/copy-corrupt-content/.serialization-c9h3pjr0/failure.json", + "sha256": "d1719f3f6a94c2669828ba690d1867132a9eb361ed24b4f2b0a3ef7a75f5aab7", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Staged copy digest or byte count changed\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/copy-corrupt-content/.serialization-c9h3pjr0\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/copy-corrupt-content/.serialization-c9h3pjr0/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/copy-corrupt-content/.serialization-c9h3pjr0/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-corrupt-content/.serialization-c9h3pjr0/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/copy-corrupt-content/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-corrupt-content/witness.json", + "sha256": "35a69d4f98a971b2463cfc889f102884891ccf2a76b94441b1ce36fb54a68c1e", + "utf8": "z\"active\":[1,2],\"args\":[null,[0-1]],\"code\":{\"gates\":[[1,[0],[1-2]]],\"outputs\":[[1,2],[0,1]],\"soles\":3,\"sources\":[[[2,1,0],1]-[[0,1,2],2]]},\"kind\":[null,\"in#],\"labels\":[[1,[[2,3],[0,1]],2-[1,3]]],\"pieces\":[[[0,1,2],2,[0,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1241, + "path": "science/component/copy-hash-error/.serialization-czhivgso/failure.json", + "sha256": "9d12ddc72c80a5c505692cb834fcbc305599b3694638e4e730a41c02d7a51114", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/copy-hash-error/.serialization-czhivgso\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/copy-hash-error/.serialization-czhivgso/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/copy-hash-error/.serialization-czhivgso/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-hash-error/.serialization-czhivgso/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/copy-hash-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/copy-hash-error/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 1240, + "path": "science/component/copy-read-error/.serialization-2_n44ktm/failure.json", + "sha256": "50e1f66426e6330599eb55fa02553c1149061d8f445124043299bdcd411fa6f5", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/copy-read-error/.serialization-2_n44ktm\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/copy-read-error/.serialization-2_n44ktm/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/copy-read-error/.serialization-2_n44ktm/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-read-error/.serialization-2_n44ktm/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/copy-read-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/copy-read-error/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 29, + "path": "science/component/depth-30/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-30/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 294, + "path": "science/component/depth-30/candidate/witness.json", + "sha256": "83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/depth-30/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-30/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 294, + "path": "science/component/depth-30/original/witness.json", + "sha256": "83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/depth-33/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-33/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 300, + "path": "science/component/depth-33/candidate/witness.json", + "sha256": "9606b4a94c188fff0f9f7f210ece8b8899dab46eb68fc89ecda75f5d4a58ab2a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/depth-33/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-33/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 300, + "path": "science/component/depth-33/original/witness.json", + "sha256": "9606b4a94c188fff0f9f7f210ece8b8899dab46eb68fc89ecda75f5d4a58ab2a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 2, + "path": "science/component/empty/candidate/rank-trace.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "utf8": "[]" + }, + { + "bytes": 22, + "path": "science/component/empty/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 126, + "path": "science/component/empty/candidate/witness.json", + "sha256": "34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405", + "utf8": "{\"active\":[],\"args\":[],\"code\":{\"gates\":[],\"outputs\":[],\"roles\":0,\"sources\":[]},\"kind\":[],\"labels\":[],\"pieces\":[],\"support\":[]}" + }, + { + "bytes": 2, + "path": "science/component/empty/original/rank-trace.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "utf8": "[]" + }, + { + "bytes": 22, + "path": "science/component/empty/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 126, + "path": "science/component/empty/original/witness.json", + "sha256": "34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405", + "utf8": "{\"active\":[],\"args\":[],\"code\":{\"gates\":[],\"outputs\":[],\"roles\":0,\"sources\":[]},\"kind\":[],\"labels\":[],\"pieces\":[],\"support\":[]}" + }, + { + "bytes": 29, + "path": "science/component/existing-finals/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/existing-finals/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/existing-finals/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/existing-finals-reference/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/existing-finals-reference/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/existing-finals-reference/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1434, + "path": "science/component/exit-json-drift/.serialization-rfuhvwa9/failure.json", + "sha256": "3861bef3b9529ae0505bf872c4d4742797ee1e4b8e574d169ac40e30077aeef9", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"JSON encoder binding changed: default\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"precleanup_freshness\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/exit-json-drift/.serialization-rfuhvwa9\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/exit-json-drift/.serialization-rfuhvwa9/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/exit-json-drift/.serialization-rfuhvwa9/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/exit-json-drift/.serialization-rfuhvwa9/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/exit-json-drift/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/exit-json-drift/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/exit-json-drift/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1256, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-2ww_z9xd/failure.json", + "sha256": "30a2b62271623356133b2d44dea606011d10774cf5209f88aa971639464f2017", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-exact_witness_sha256/candidate/.serialization-2ww_z9xd\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-2ww_z9xd/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-2ww_z9xd/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-2ww_z9xd/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1251, + "path": "science/component/expected-rank_call_count/candidate/.serialization-mdv34g20/failure.json", + "sha256": "0eda5a8a6ed461fd712fd094c2648cf40bda3d08311dc3c29a75b65103eb2a71", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-rank_call_count/candidate/.serialization-mdv34g20\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-rank_call_count/candidate/.serialization-mdv34g20/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-rank_call_count/candidate/.serialization-mdv34g20/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-rank_call_count/candidate/.serialization-mdv34g20/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1262, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-bg1c06gs/failure.json", + "sha256": "391817436359c3b163aa06ad465431a28d9439e1119b9c800d8e06fe15eccdd2", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-rank_distinct_matrix_count/candidate/.serialization-bg1c06gs\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-bg1c06gs/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-bg1c06gs/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-bg1c06gs/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1253, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-4hh874g9/failure.json", + "sha256": "92ef96a0a6b51ca446adb5f4e2807f5e06cc9910d440a650e52e5de37a71d503", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-rank_trace_sha256/candidate/.serialization-4hh874g9\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-4hh874g9/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-4hh874g9/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-4hh874g9/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1249, + "path": "science/component/expected-result_sha256/candidate/.serialization-2p679p7w/failure.json", + "sha256": "78c89b34cbf8274f0405dadea14a324740ad03bb1d57f160c912892a56f93014", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/expected-result_sha256/candidate/.serialization-2p679p7w\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-result_sha256/candidate/.serialization-2p679p7w/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-result_sha256/candidate/.serialization-2p679p7w/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-result_sha256/candidate/.serialization-2p679p7w/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1356, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-c0qrmz9m/failure.json", + "sha256": "f05f48690ce1fbe55614f351c7fb68519c581c9fbb27fd8706c22fd2f3da7f79", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_after_close-rank-trace.json/.serialization-c0qrmz9m\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-c0qrmz9m/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-c0qrmz9m/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-c0qrmz9m/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-rank-trace.json/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1180, + "path": "science/component/failure-final_after_close-result.json/.serialization-7b9y7ych/failure.json", + "sha256": "95a2ad9baf567a4654f8172f73bf7d40bfa1aebd71be4ed3426c1af0ca074c01", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_after_close-result.json/.serialization-7b9y7ych\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-result.json/.serialization-7b9y7ych/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-result.json/.serialization-7b9y7ych/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-result.json/.serialization-7b9y7ych/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-result.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1267, + "path": "science/component/failure-final_after_close-witness.json/.serialization-aee8bgsc/failure.json", + "sha256": "325dfdfd74750021cba9ea2ca69a685fce973d599f4e2a79db929a6798d8e178", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_after_close-witness.json/.serialization-aee8bgsc\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-witness.json/.serialization-aee8bgsc/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-witness.json/.serialization-aee8bgsc/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-witness.json/.serialization-aee8bgsc/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-witness.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1350, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-8mn1zyq9/failure.json", + "sha256": "232a5af9bdb3f9d378cec6de5474303c44a8f98d195e7e221f9a2e95b79e627a", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_flush-rank-trace.json/.serialization-8mn1zyq9\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-8mn1zyq9/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-8mn1zyq9/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-8mn1zyq9/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-rank-trace.json/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1174, + "path": "science/component/failure-final_flush-result.json/.serialization-6d30yxhn/failure.json", + "sha256": "36175792a015aa2f719cf35adaca8c6daa97d8af26407dc8a50281ff23daa963", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_flush-result.json/.serialization-6d30yxhn\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-result.json/.serialization-6d30yxhn/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-result.json/.serialization-6d30yxhn/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-result.json/.serialization-6d30yxhn/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-result.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1261, + "path": "science/component/failure-final_flush-witness.json/.serialization-b1pj4pha/failure.json", + "sha256": "a0468f693a8c0a9da632bd71c9b7ac3111aac9bd31997fd0eb5a2a4586f50d73", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_flush-witness.json/.serialization-b1pj4pha\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-witness.json/.serialization-b1pj4pha/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-witness.json/.serialization-b1pj4pha/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-witness.json/.serialization-b1pj4pha/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-witness.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1347, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-19wg121c/failure.json", + "sha256": "33d95e6d2711324197bb948ee7e233e9f406f84cf27065efd8b3624fc9205d86", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_open-rank-trace.json/.serialization-19wg121c\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-19wg121c/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-19wg121c/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-19wg121c/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1171, + "path": "science/component/failure-final_open-result.json/.serialization-l3ikcnim/failure.json", + "sha256": "d17a97767cc1f2b1ab0683d8014f582c75b588220ad51af11bf77dcbc139ceec", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_open-result.json/.serialization-l3ikcnim\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_open-result.json/.serialization-l3ikcnim/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-result.json/.serialization-l3ikcnim/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-result.json/.serialization-l3ikcnim/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1256, + "path": "science/component/failure-final_open-witness.json/.serialization-dco0pyd4/failure.json", + "sha256": "e4132fea3966f5c2c6381a98847669e6925791e60845a8b040e79f898511c415", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_open-witness.json/.serialization-dco0pyd4\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_open-witness.json/.serialization-dco0pyd4/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-witness.json/.serialization-dco0pyd4/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-witness.json/.serialization-dco0pyd4/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1349, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-aekvlc4t/failure.json", + "sha256": "af1ef75988b83a8d3b6d10ab7a5369f0e453d50b2475db58d8f6ecb595709c25", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_write-rank-trace.json/.serialization-aekvlc4t\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-aekvlc4t/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-aekvlc4t/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-aekvlc4t/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 0, + "path": "science/component/failure-final_write-rank-trace.json/rank-trace.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1173, + "path": "science/component/failure-final_write-result.json/.serialization-asmbg9jq/failure.json", + "sha256": "bbf657edfb491116ce1753e983de4dce402139069e5204ae4a8eb8ada2e0add6", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_write-result.json/.serialization-asmbg9jq\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_write-result.json/.serialization-asmbg9jq/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-result.json/.serialization-asmbg9jq/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-result.json/.serialization-asmbg9jq/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 0, + "path": "science/component/failure-final_write-result.json/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 1258, + "path": "science/component/failure-final_write-witness.json/.serialization-mnpfz2le/failure.json", + "sha256": "255565ced898af1fa0a8685e13e28526a06d82f30e03f9d3d5bc8a16b5d109aa", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-final_write-witness.json/.serialization-mnpfz2le\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_write-witness.json/.serialization-mnpfz2le/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-witness.json/.serialization-mnpfz2le/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-witness.json/.serialization-mnpfz2le/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/failure-final_write-witness.json/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 665, + "path": "science/component/failure-stage_after_close/.serialization-6bmn05y_/failure.json", + "sha256": "6afa1bfaaab2793c0a199ef338f536ebbc515b7e0620174cc2c72118d9ecd6f5", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_after_close/.serialization-6bmn05y_\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 22, + "path": "science/component/failure-stage_after_close/.serialization-6bmn05y_/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 659, + "path": "science/component/failure-stage_flush/.serialization-xo6incq2/failure.json", + "sha256": "31cf3ec747c9a2ad0aa74804755e313ed38cd558afd9755fa88d4bad30c24117", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_flush/.serialization-xo6incq2\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 22, + "path": "science/component/failure-stage_flush/.serialization-xo6incq2/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 655, + "path": "science/component/failure-stage_hash/.serialization-fygyqwbq/failure.json", + "sha256": "68a13862c0178cb27a405022b6c56ca3ccd670332c1cd7c51dff2f47be5b2c47", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":0,\"retained_stage_stat_bytes\":0}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_hash/.serialization-fygyqwbq\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 0, + "path": "science/component/failure-stage_hash/.serialization-fygyqwbq/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 658, + "path": "science/component/failure-stage_open/.serialization-g0mwmxvz/failure.json", + "sha256": "1ac7617bd7f5b1dbb1752b03a8fe6a52384df6bc0eb4080073e9dbd3a77262aa", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":0,\"retained_stage_stat_bytes\":null}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_open/.serialization-g0mwmxvz\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 657, + "path": "science/component/failure-stage_write/.serialization-gqbb5nwe/failure.json", + "sha256": "8c9f33a15259f292ecda145a91b14f4e601d22cb454108e2b3b80992ff4529da", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":0}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/failure-stage_write/.serialization-gqbb5nwe\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 0, + "path": "science/component/failure-stage_write/.serialization-gqbb5nwe/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 29, + "path": "science/component/fallback-exit-json-drift/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/fallback-exit-json-drift/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/fallback-exit-json-drift/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/int-subclass/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/int-subclass/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/int-subclass/candidate/witness.json", + "sha256": "273eda2074ac0c67d1585cf11893cc6fd58e9fc3273b6efb9ad4de31a9de3d9c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[7]}" + }, + { + "bytes": 29, + "path": "science/component/int-subclass/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/int-subclass/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/int-subclass/original/witness.json", + "sha256": "273eda2074ac0c67d1585cf11893cc6fd58e9fc3273b6efb9ad4de31a9de3d9c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[7]}" + }, + { + "bytes": 37, + "path": "science/component/interned-rank-rows/candidate/rank-trace.json", + "sha256": "28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2", + "utf8": "[[[1,2,3],2],[[1,2,3],1],[[1,2,3],2]]" + }, + { + "bytes": 22, + "path": "science/component/interned-rank-rows/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/interned-rank-rows/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 37, + "path": "science/component/interned-rank-rows/original/rank-trace.json", + "sha256": "28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2", + "utf8": "[[[1,2,3],2],[[1,2,3],1],[[1,2,3],2]]" + }, + { + "bytes": 22, + "path": "science/component/interned-rank-rows/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/interned-rank-rows/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/nonstring-supported-keys/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 17, + "path": "science/component/nonstring-supported-keys/candidate/result.json", + "sha256": "a71fc868af5e004c2efbfdf16bb2b679c348f2e25065b30b06df846eb32074a5", + "utf8": "{\"1\":\"a\",\"2\":\"b\"}" + }, + { + "bytes": 242, + "path": "science/component/nonstring-supported-keys/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/nonstring-supported-keys/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 17, + "path": "science/component/nonstring-supported-keys/original/result.json", + "sha256": "a71fc868af5e004c2efbfdf16bb2b679c348f2e25065b30b06df846eb32074a5", + "utf8": "{\"1\":\"a\",\"2\":\"b\"}" + }, + { + "bytes": 242, + "path": "science/component/nonstring-supported-keys/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/ordinary/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/ordinary/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/ordinary/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/ordinary/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/ordinary/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/ordinary/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/path-candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/path-candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/path-candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/path-original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/path-original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/path-original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 719, + "path": "science/component/primary-plus-close-error/.serialization-v6bwrsxw/failure.json", + "sha256": "495921b54514694f8e68d9abdb37f46ef1620eed5d9e4b8cdf6bb5a782208528", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"close_errors\":[{\"phase\":\"stage\",\"type\":\"OSError\"}],\"copy_bytes_limit\":31,\"error\":{\"message\":\"primary write failure\",\"type\":\"ValueError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":0}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/primary-plus-close-error/.serialization-v6bwrsxw\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 0, + "path": "science/component/primary-plus-close-error/.serialization-v6bwrsxw/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 0, + "path": "science/component/primary-plus-manifest-error/.serialization-v9f52f28/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 29, + "path": "science/component/rows-1/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/rows-1/candidate/witness.json", + "sha256": "02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/rows-1/original/witness.json", + "sha256": "02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1023/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1023/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4241, + "path": "science/component/rows-1023/candidate/witness.json", + "sha256": "d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1023/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1023/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4241, + "path": "science/component/rows-1023/original/witness.json", + "sha256": "d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1024/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1024/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4246, + "path": "science/component/rows-1024/candidate/witness.json", + "sha256": "356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1024/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1024/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4246, + "path": "science/component/rows-1024/original/witness.json", + "sha256": "356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1025/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1025/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4251, + "path": "science/component/rows-1025/candidate/witness.json", + "sha256": "cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1025/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1025/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4251, + "path": "science/component/rows-1025/original/witness.json", + "sha256": "cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024]}" + }, + { + "bytes": 29, + "path": "science/component/rows-2048/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-2048/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 9366, + "path": "science/component/rows-2048/candidate/witness.json", + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047]}" + }, + { + "bytes": 29, + "path": "science/component/rows-2048/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-2048/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 9366, + "path": "science/component/rows-2048/original/witness.json", + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047]}" + }, + { + "bytes": 29, + "path": "science/component/scalars-unicode-wide/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/scalars-unicode-wide/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1132, + "path": "science/component/scalars-unicode-wide/candidate/witness.json", + "sha256": "413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,true,false,0.0,-0.0,1.25,Infinity,-Infinity,NaN,\"\\\\\\\"\\b\\f\\n\\r\\t\\u0000\",\"\\u1234\\ud83d\\ude42\\ud800\\udfff\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,-1,9007199254740991,9007199254740992,18446744073709551615,18446744073709551616,-18446744073709551616,233878353180758339522999985846145153701620551470473491834203652732173515904946260341745278133995563398543833002737305755265667540290727766807493212876909875594659990525149511668584314541080529232920507339280366608543284100729323707744847529244028704375222828075048053441873066841431886770996808740827211603475038378174976712681510622226105042933701081639420796456625832053480792840170201978746863875653930536130692114534553508213773677543990855402845952690966422979996611285214472124176258420341690709615016875950078934740489536866665063730098188523517481467195831094846379597369859669346905433590926427903227017534401181934141410249481203446155011741023897916350226373873852700758028505317376]}" + }, + { + "bytes": 29, + "path": "science/component/scalars-unicode-wide/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/scalars-unicode-wide/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1132, + "path": "science/component/scalars-unicode-wide/original/witness.json", + "sha256": "413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,true,false,0.0,-0.0,1.25,Infinity,-Infinity,NaN,\"\\\\\\\"\\b\\f\\n\\r\\t\\u0000\",\"\\u1234\\ud83d\\ude42\\ud800\\udfff\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,-1,9007199254740991,9007199254740992,18446744073709551615,18446744073709551616,-18446744073709551616,233878353180758339522999985846145153701620551470473491834203652732173515904946260341745278133995563398543833002737305755265667540290727766807493212876909875594659990525149511668584314541080529232920507339280366608543284100729323707744847529244028704375222828075048053441873066841431886770996808740827211603475038378174976712681510622226105042933701081639420796456625832053480792840170201978746863875653930536130692114534553508213773677543990855402845952690966422979996611285214472124176258420341690709615016875950078934740489536866665063730098188523517481467195831094846379597369859669346905433590926427903227017534401181934141410249481203446155011741023897916350226373873852700758028505317376]}" + }, + { + "bytes": 1247, + "path": "science/component/short-final-0/.serialization-epxr7n1y/failure.json", + "sha256": "a1b4c904ba4cebe3051b6c0b4c53ed833e2da12e796c68d388e469a99cf7e9f5", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Short final write; no retry\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/short-final-0/.serialization-epxr7n1y\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/short-final-0/.serialization-epxr7n1y/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/short-final-0/.serialization-epxr7n1y/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/short-final-0/.serialization-epxr7n1y/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/short-final-0/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/short-final-0/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 1247, + "path": "science/component/short-final-1/.serialization-nwk_ylfd/failure.json", + "sha256": "3c1c1d1df77a4253dab49e38514fab3e50bfd797a931eedce15d080ea563de24", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Short final write; no retry\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/short-final-1/.serialization-nwk_ylfd\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/short-final-1/.serialization-nwk_ylfd/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/short-final-1/.serialization-nwk_ylfd/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/short-final-1/.serialization-nwk_ylfd/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/short-final-1/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1, + "path": "science/component/short-final-1/witness.json", + "sha256": "021fb596db81e6d02bf3d2586ee3981fe519f275c0ac9ca76bbcf2ebb4097d96", + "utf8": "{" + }, + { + "bytes": 1264, + "path": "science/component/stage-mutated-size/.serialization-mstwyeu9/failure.json", + "sha256": "9a8b0e6080d94a3c72c607c0b76ac1819a233e5216655bb0e7405718aac0a6ab", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Staged artifact changed before copy\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":243,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/stage-mutated-size/.serialization-mstwyeu9\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/stage-mutated-size/.serialization-mstwyeu9/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/stage-mutated-size/.serialization-mstwyeu9/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 243, + "path": "science/component/stage-mutated-size/.serialization-mstwyeu9/witness.json", + "sha256": "ee4528b047c1a5d1af09bda2e753f72b43e8f383ae4b1622512a77b16221af09", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]} " + }, + { + "bytes": 22, + "path": "science/component/stage-mutated-size/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1230, + "path": "science/component/state-changed/.serialization-958z7cgq/failure.json", + "sha256": "635283ba9554554ebc2b977983fae1f5d8d34d815aecc642d4ac22524481a3e7", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":245,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":245,\"retained_stage_stat_bytes\":245,\"sha256\":\"62e057a3ce3c149ef913959ca856f161a9ad409efce043208223ef4b5fd98667\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/state-changed/.serialization-958z7cgq\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/state-changed/.serialization-958z7cgq/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/state-changed/.serialization-958z7cgq/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 245, + "path": "science/component/state-changed/.serialization-958z7cgq/witness.json", + "sha256": "62e057a3ce3c149ef913959ca856f161a9ad409efce043208223ef4b5fd98667", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3,99]}" + }, + { + "bytes": 29, + "path": "science/component/state-first/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/state-first/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/state-first/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 991, + "path": "science/component/wide-digit-error/candidate/.serialization-tuz_nwbf/failure.json", + "sha256": "b78abb0fb8456b66e6d54bbf8891af61ba27eab292c3e6bd1076f2442c052eff", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":8,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Exceeds the limit (640 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit\",\"type\":\"ValueError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":235,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":235,\"retained_stage_stat_bytes\":235}},\"largest_batch_bytes\":27,\"phase\":\"stage:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/wide-digit-error/candidate/.serialization-tuz_nwbf\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 22, + "path": "science/component/wide-digit-error/candidate/.serialization-tuz_nwbf/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 235, + "path": "science/component/wide-digit-error/candidate/.serialization-tuz_nwbf/witness.json", + "sha256": "f4967dabbd5244ab63f156add8d56454d67b1fdddc3ee5d032a17b1fc28a95a4", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[" + }, + { + "bytes": 29, + "path": "science/component/wide-unlimited/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/wide-unlimited/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 12281, + "path": "science/component/wide-unlimited/candidate/witness.json", + "sha256": "4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376,-398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376]}" + }, + { + "bytes": 29, + "path": "science/component/wide-unlimited/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/wide-unlimited/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 12281, + "path": "science/component/wide-unlimited/original/witness.json", + "sha256": "4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376,-398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376]}" + }, + { + "bytes": 0, + "path": "stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 79, + "path": "stdout.txt", + "sha256": "b1e5d8aacb1b6e269fae5a140a4fd53351d84161ee1c5fc0a82a26b8f78795b5", + "utf8": "{\"mode\": \"controls\", \"optimization\": 1, \"status\": \"FINITE_COMPONENT_RETURNED\"}\n" + }, + { + "bytes": 80, + "path": "usage.json", + "sha256": "a44fe3dd1f60d7988e4db5db58e6051b43f3c8acdea4c3278f22e4b203a8fa60", + "utf8": "{\"user_seconds\":0.42,\"system_seconds\":0.06,\"kernel_max_rss_kib\":23672,\"exit\":0}\n" + } + ], + "original_run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O", + "schema": "verbatim-finite-run-bundle-v1", + "total_bytes": 237294 +} diff --git a/research/h25-bounded-serializer/validation/execution-v2-serializer-controls-normal-raw.json b/research/h25-bounded-serializer/validation/execution-v2-serializer-controls-normal-raw.json new file mode 100644 index 0000000000..0fe64367b7 --- /dev/null +++ b/research/h25-bounded-serializer/validation/execution-v2-serializer-controls-normal-raw.json @@ -0,0 +1,1808 @@ +{ + "file_count": 300, + "files": [ + { + "bytes": 1073, + "path": "START.json", + "sha256": "e40a06d1ada8d740bfed80629bf9d9d0f63626ddaa65a1d63b0d80aa41deba59", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science\",\n \"--lanes\",\n \"serializer-controls\",\n \"--finite-only\"\n ],\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-controls-normal\",\n \"label\": \"serializer-controls-normal\",\n \"phase_cap_seconds\": 600,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"spent_before_seconds\": 0.0,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\"\n}\n" + }, + { + "bytes": 2048, + "path": "receipt.json", + "sha256": "4ed9637fb3f45bcbeb85e17f3b3cd6597ebeb389083f9be99f163efa9453b503", + "utf8": "{\n \"budget_phase_sha256\": \"b09ea5b4d521f13b27925ac0055440bf0edc82b66a71edff7df427120e77163a\",\n \"command\": [\n \"/usr/bin/python3.12\",\n \"-B\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"--output\",\n \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science\",\n \"--lanes\",\n \"serializer-controls\",\n \"--finite-only\"\n ],\n \"exit\": 0,\n \"fractions_sha256\": \"cf33568f7b767f66896995a7a81cc662e8be226f2e58efb61d2028f64eb5d231\",\n \"job\": \"serializer-controls-normal\",\n \"label\": \"serializer-controls-normal\",\n \"log_read_chunk_bytes\": 65536,\n \"output_cap_observed_at\": null,\n \"phase_cap_seconds\": 600,\n \"platform\": \"Linux-7.0.0-38-generic-x86_64-with-glibc2.39\",\n \"python\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"retained_log_bytes_stable\": true,\n \"runner_lifetime_max_rss_kib\": 18160,\n \"runner_sha256\": \"32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a\",\n \"runner_system_seconds\": 0.007139,\n \"runner_user_seconds\": 0.013476999999999996,\n \"runner_wall_seconds\": 0.4714004519628361,\n \"sampled_process_group_rss_bytes\": 24567808,\n \"source_bytes_and_modes_unchanged\": true,\n \"spent_before_seconds\": 0.0,\n \"stage_sha256\": \"13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04\",\n \"status\": \"PASS\",\n \"stderr_bytes\": 0,\n \"stderr_final_bytes\": 0,\n \"stderr_sha256\": \"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\",\n \"stdout_bytes\": 79,\n \"stdout_final_bytes\": 79,\n \"stdout_sha256\": \"1a0ef58a650559d0f38dba77eb5c9dacaeaa4a39405e04a38f3e420367a5220b\",\n \"termination\": null,\n \"usage\": {\n \"exit\": 0,\n \"kernel_max_rss_kib\": 22592,\n \"system_seconds\": 0.1,\n \"user_seconds\": 0.3\n },\n \"wall_seconds\": 0.45877077197656035\n}\n" + }, + { + "bytes": 12958, + "path": "science/adapter-boundary.json", + "sha256": "68c9bfc3e0bd6726b8363e52d7abd780930502979c5f18ed694eda3d9b5184d2", + "utf8": "{\n \"after\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__future__\": \"/usr/lib/python3.12/__future__.py\",\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bisect\": \"/usr/lib/python3.12/bisect.py\",\n \"bounded_serialization\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/bounded_serialization.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"component_consumer\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/component_consumer.py\",\n \"contextlib\": \"/usr/lib/python3.12/contextlib.py\",\n \"copy\": \"/usr/lib/python3.12/copy.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"random\": \"/usr/lib/python3.12/random.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reference\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/reference.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"serialization_controls\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/package/serialization_controls.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"tempfile\": \"/usr/lib/python3.12/tempfile.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"weakref\": \"/usr/lib/python3.12/weakref.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"before\": {\n \"assumptions\": [\n \"Trusted local CPython3.12/Linux finite environment; no hostile concurrent host/module/loader mutation.\",\n \"File hashes authenticate recorded interpreter, module sources and observed libraries; this is not complete host attestation or original whole-H25 binary custody.\",\n \"Before/after hashes and actual consumer bindings are required in each admitted process; reviewed source fixed, scientific/native provenance never imported.\",\n \"Inventory explicitly imports standard-library modules; interpreter system-site initialization also loaded the recorded system-site hooks. No serializer/control/scientific target was imported or executed.\",\n \"Preparation and final metadata publication physical costs remain outside a complete measured boundary and are not zero.\",\n \"Recorded source file hashes do not independently attest cached bytecode; trusted host/interpreter import machinery is an explicit finite-environment assumption.\"\n ],\n \"module_origins\": {\n \"__main__\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/stages/serializer-v2/integration/full_driver.py\",\n \"_bz2\": \"/usr/lib/python3.12/lib-dynload/_bz2.cpython-312-x86_64-linux-gnu.so\",\n \"_collections_abc\": \"/usr/lib/python3.12/_collections_abc.py\",\n \"_compression\": \"/usr/lib/python3.12/_compression.py\",\n \"_distutils_hack\": \"/usr/lib/python3/dist-packages/_distutils_hack/__init__.py\",\n \"_frozen_importlib\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"_frozen_importlib_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"_hashlib\": \"/usr/lib/python3.12/lib-dynload/_hashlib.cpython-312-x86_64-linux-gnu.so\",\n \"_json\": \"/usr/lib/python3.12/lib-dynload/_json.cpython-312-x86_64-linux-gnu.so\",\n \"_lzma\": \"/usr/lib/python3.12/lib-dynload/_lzma.cpython-312-x86_64-linux-gnu.so\",\n \"_sitebuiltins\": \"/usr/lib/python3.12/_sitebuiltins.py\",\n \"_weakrefset\": \"/usr/lib/python3.12/_weakrefset.py\",\n \"abc\": \"/usr/lib/python3.12/abc.py\",\n \"apport_python_hook\": \"/usr/lib/python3/dist-packages/apport_python_hook.py\",\n \"argparse\": \"/usr/lib/python3.12/argparse.py\",\n \"bz2\": \"/usr/lib/python3.12/bz2.py\",\n \"codecs\": \"/usr/lib/python3.12/codecs.py\",\n \"collections\": \"/usr/lib/python3.12/collections/__init__.py\",\n \"copyreg\": \"/usr/lib/python3.12/copyreg.py\",\n \"encodings\": \"/usr/lib/python3.12/encodings/__init__.py\",\n \"encodings.aliases\": \"/usr/lib/python3.12/encodings/aliases.py\",\n \"encodings.utf_8\": \"/usr/lib/python3.12/encodings/utf_8.py\",\n \"enum\": \"/usr/lib/python3.12/enum.py\",\n \"fnmatch\": \"/usr/lib/python3.12/fnmatch.py\",\n \"functools\": \"/usr/lib/python3.12/functools.py\",\n \"genericpath\": \"/usr/lib/python3.12/genericpath.py\",\n \"gettext\": \"/usr/lib/python3.12/gettext.py\",\n \"hashlib\": \"/usr/lib/python3.12/hashlib.py\",\n \"importlib\": \"/usr/lib/python3.12/importlib/__init__.py\",\n \"importlib._abc\": \"/usr/lib/python3.12/importlib/_abc.py\",\n \"importlib._bootstrap\": \"/usr/lib/python3.12/importlib/_bootstrap.py\",\n \"importlib._bootstrap_external\": \"/usr/lib/python3.12/importlib/_bootstrap_external.py\",\n \"importlib.machinery\": \"/usr/lib/python3.12/importlib/machinery.py\",\n \"importlib.util\": \"/usr/lib/python3.12/importlib/util.py\",\n \"io\": \"/usr/lib/python3.12/io.py\",\n \"ipaddress\": \"/usr/lib/python3.12/ipaddress.py\",\n \"json\": \"/usr/lib/python3.12/json/__init__.py\",\n \"json.decoder\": \"/usr/lib/python3.12/json/decoder.py\",\n \"json.encoder\": \"/usr/lib/python3.12/json/encoder.py\",\n \"json.scanner\": \"/usr/lib/python3.12/json/scanner.py\",\n \"keyword\": \"/usr/lib/python3.12/keyword.py\",\n \"locale\": \"/usr/lib/python3.12/locale.py\",\n \"lzma\": \"/usr/lib/python3.12/lzma.py\",\n \"mpl_toolkits\": \"/usr/lib/python3/dist-packages/mpl_toolkits/__init__.py\",\n \"ntpath\": \"/usr/lib/python3.12/ntpath.py\",\n \"operator\": \"/usr/lib/python3.12/operator.py\",\n \"os\": \"/usr/lib/python3.12/os.py\",\n \"os.path\": \"/usr/lib/python3.12/posixpath.py\",\n \"pathlib\": \"/usr/lib/python3.12/pathlib.py\",\n \"posixpath\": \"/usr/lib/python3.12/posixpath.py\",\n \"re\": \"/usr/lib/python3.12/re/__init__.py\",\n \"re._casefix\": \"/usr/lib/python3.12/re/_casefix.py\",\n \"re._compiler\": \"/usr/lib/python3.12/re/_compiler.py\",\n \"re._constants\": \"/usr/lib/python3.12/re/_constants.py\",\n \"re._parser\": \"/usr/lib/python3.12/re/_parser.py\",\n \"reprlib\": \"/usr/lib/python3.12/reprlib.py\",\n \"shutil\": \"/usr/lib/python3.12/shutil.py\",\n \"site\": \"/usr/lib/python3.12/site.py\",\n \"sitecustomize\": \"/etc/python3.12/sitecustomize.py\",\n \"stat\": \"/usr/lib/python3.12/stat.py\",\n \"threading\": \"/usr/lib/python3.12/threading.py\",\n \"types\": \"/usr/lib/python3.12/types.py\",\n \"urllib\": \"/usr/lib/python3.12/urllib/__init__.py\",\n \"urllib.parse\": \"/usr/lib/python3.12/urllib/parse.py\",\n \"warnings\": \"/usr/lib/python3.12/warnings.py\",\n \"zipimport\": \"/usr/lib/python3.12/zipimport.py\"\n },\n \"runtime_file_count\": 85,\n \"runtime_manifest_sha256\": \"972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02\",\n \"serializer_manifest_sha256\": \"5cbf632753d81558487f453e2ac9b92a02a0b26c0f6da59b28c71c6db415ae1e\",\n \"serializer_payload_files\": 21\n },\n \"component_status\": \"SERIALIZATION_FINITE_PASS\",\n \"dont_write_bytecode\": true,\n \"environment\": {\n \"LC_ALL\": \"C.UTF-8\",\n \"PYTHONDONTWRITEBYTECODE\": \"1\",\n \"PYTHONHASHSEED\": \"0\",\n \"PYTHONNOUSERSITE\": \"1\",\n \"PYTHONSAFEPATH\": \"1\",\n \"TZ\": \"UTC\"\n },\n \"executable\": \"/usr/bin/python3.12\",\n \"executable_realpath\": \"/usr/bin/python3.12\",\n \"fixture_rows\": null,\n \"mode\": \"controls\",\n \"no_user_site\": 1,\n \"optimization\": 0,\n \"python_version\": \"3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]\",\n \"safe_path\": true,\n \"scope\": \"Supported finite serializer host only; no full H25 custody/performance claim\",\n \"status\": \"FINITE_COMPONENT_RETURNED\"\n}\n" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-169/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-169/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 408, + "path": "science/component/byte-bound-169/candidate/witness.json", + "sha256": "15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-169/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-169/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 408, + "path": "science/component/byte-bound-169/original/witness.json", + "sha256": "15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-170/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-170/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 409, + "path": "science/component/byte-bound-170/candidate/witness.json", + "sha256": "1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-170/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-170/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 409, + "path": "science/component/byte-bound-170/original/witness.json", + "sha256": "1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-171/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-171/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 410, + "path": "science/component/byte-bound-171/candidate/witness.json", + "sha256": "1c476c4ab260493228029992b948640ee4938756f14f6c9431ff7cb14b8ac89b", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/byte-bound-171/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/byte-bound-171/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 410, + "path": "science/component/byte-bound-171/original/witness.json", + "sha256": "1c476c4ab260493228029992b948640ee4938756f14f6c9431ff7cb14b8ac89b", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\"z\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-dict/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-dict/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/callback-dict/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-dict/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-dict/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/callback-dict/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-list/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-list/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 241, + "path": "science/component/callback-list/candidate/witness.json", + "sha256": "2c5a0741bc48d9addda2820488ce0470d7a434cb6b5cf3c41e4f271fbdd4e50a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"in\",\"x\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/callback-list/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/callback-list/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 241, + "path": "science/component/callback-list/original/witness.json", + "sha256": "2c5a0741bc48d9addda2820488ce0470d7a434cb6b5cf3c41e4f271fbdd4e50a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[\"in\",\"x\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1458, + "path": "science/component/cleanup-rmdir-error/.serialization-_eykpp4g/failure.json", + "sha256": "df8b93c053b88744b632c0a1b2a16ee1afc84affe1a75e3fce1c0e8982d9998b", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[\"result.json\",\"witness.json\",\"rank-trace.json\"],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":null,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":null,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":null,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"cleanup\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/cleanup-rmdir-error/.serialization-_eykpp4g\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/cleanup-rmdir-error/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/cleanup-rmdir-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/cleanup-rmdir-error/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1423, + "path": "science/component/cleanup-unlink-error/.serialization-j3c6hi7s/failure.json", + "sha256": "93ecd5bcf6e4756f888b0011775b8e8ec8787a721fc9fbed73625a27508f6139", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[\"result.json\"],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":null,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"cleanup\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/cleanup-unlink-error/.serialization-j3c6hi7s\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/cleanup-unlink-error/.serialization-j3c6hi7s/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 242, + "path": "science/component/cleanup-unlink-error/.serialization-j3c6hi7s/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/cleanup-unlink-error/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/cleanup-unlink-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/cleanup-unlink-error/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 167, + "path": "science/component/component-control-acceptance.json", + "sha256": "fba682206a720d8c8c3a167c2d4e57d6b6875d7e82e846f33cf138019f56fd56", + "utf8": "{\n \"case_count\": 70,\n \"optimization\": 0,\n \"scope\": \"Finite component only; requires independent parent validation\",\n \"status\": \"COMPONENT_CONTROL_ORDER_CHECKED\"\n}\n" + }, + { + "bytes": 88806, + "path": "science/component/controls.json", + "sha256": "70d79f2c617a389d4b09729bcd42645bc1926784e70478245c75acba0aaf90b0", + "utf8": "{\n \"case_count\": 70,\n \"cases\": [\n {\n \"case\": \"ordinary\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/ordinary/candidate/.serialization-bspd0do7\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"empty\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 0,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 2,\n \"copy_read_bytes\": 2,\n \"copy_sha256\": \"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945\",\n \"copy_write_bytes\": 2,\n \"hashed_bytes\": 2,\n \"sha256\": \"4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 126,\n \"copy_read_bytes\": 126,\n \"copy_sha256\": \"34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405\",\n \"copy_write_bytes\": 126,\n \"hashed_bytes\": 126,\n \"sha256\": \"34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405\"\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/empty/candidate/.serialization-fm5dygsr\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 238,\n \"copy_read_bytes\": 238,\n \"copy_sha256\": \"02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443\",\n \"copy_write_bytes\": 238,\n \"hashed_bytes\": 238,\n \"sha256\": \"02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/rows-1/candidate/.serialization-_qrcwk4v\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1023\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 4241,\n \"copy_read_bytes\": 4241,\n \"copy_sha256\": \"d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143\",\n \"copy_write_bytes\": 4241,\n \"hashed_bytes\": 4241,\n \"sha256\": \"d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143\"\n }\n },\n \"largest_batch_bytes\": 4006,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/rows-1023/candidate/.serialization-4eqzfm56\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1024\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 4246,\n \"copy_read_bytes\": 4246,\n \"copy_sha256\": \"356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283\",\n \"copy_write_bytes\": 4246,\n \"hashed_bytes\": 4246,\n \"sha256\": \"356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283\"\n }\n },\n \"largest_batch_bytes\": 4011,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/rows-1024/candidate/.serialization-cl5ag1at\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-1025\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 11,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 4251,\n \"copy_read_bytes\": 4251,\n \"copy_sha256\": \"cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4\",\n \"copy_write_bytes\": 4251,\n \"hashed_bytes\": 4251,\n \"sha256\": \"cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4\"\n }\n },\n \"largest_batch_bytes\": 4011,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/rows-1025/candidate/.serialization-543v3e5z\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"rows-2048\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 11,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 9366,\n \"copy_read_bytes\": 9366,\n \"copy_sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\",\n \"copy_write_bytes\": 9366,\n \"hashed_bytes\": 9366,\n \"sha256\": \"1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6\"\n }\n },\n \"largest_batch_bytes\": 5121,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/rows-2048/candidate/.serialization-w0lx26kp\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"byte-bound-169\",\n \"operation\": {\n \"batch_bytes_limit\": 2045,\n \"batch_count\": 11,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 127,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 408,\n \"copy_read_bytes\": 408,\n \"copy_sha256\": \"15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23\",\n \"copy_write_bytes\": 408,\n \"hashed_bytes\": 408,\n \"sha256\": \"15adc2e73bff704e80f4ca856539305d8fe1e61cfbd4b777f2a6ab36358d9f23\"\n }\n },\n \"largest_batch_bytes\": 173,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/byte-bound-169/candidate/.serialization-dpq21iuc\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"byte-bound-170\",\n \"operation\": {\n \"batch_bytes_limit\": 2045,\n \"batch_count\": 11,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 127,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 409,\n \"copy_read_bytes\": 409,\n \"copy_sha256\": \"1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e\",\n \"copy_write_bytes\": 409,\n \"hashed_bytes\": 409,\n \"sha256\": \"1e69630ece2b69e5f7a8fee46f6189cbee6b3ba6a2c929b12c0067e843dbd38e\"\n }\n },\n \"largest_batch_bytes\": 174,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/byte-bound-170/candidate/.serialization-50pqy_nw\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"byte-bound-171\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"scalars-unicode-wide\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 1132,\n \"copy_read_bytes\": 1132,\n \"copy_sha256\": \"413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918\",\n \"copy_write_bytes\": 1132,\n \"hashed_bytes\": 1132,\n \"sha256\": \"413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918\"\n }\n },\n \"largest_batch_bytes\": 798,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/scalars-unicode-wide/candidate/.serialization-69q8v_p_\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"wide-unlimited\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 12281,\n \"copy_read_bytes\": 12281,\n \"copy_sha256\": \"4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c\",\n \"copy_write_bytes\": 12281,\n \"hashed_bytes\": 12281,\n \"sha256\": \"4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c\"\n }\n },\n \"largest_batch_bytes\": 12046,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/wide-unlimited/candidate/.serialization-gwob37x4\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"wide-digit-error\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 8,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Exceeds the limit (640 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit\",\n \"type\": \"ValueError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 235,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 235,\n \"retained_stage_stat_bytes\": 235\n }\n },\n \"largest_batch_bytes\": 27,\n \"phase\": \"stage:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/wide-digit-error/candidate/.serialization-a8hfjpxs\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"interned-rank-rows\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 37,\n \"copy_read_bytes\": 37,\n \"copy_sha256\": \"28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2\",\n \"copy_write_bytes\": 37,\n \"hashed_bytes\": 37,\n \"sha256\": \"28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 37,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/interned-rank-rows/candidate/.serialization-ixhpycvj\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"depth-30\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\",\n \"stage_directory\"\n ],\n \"copy_bytes_limit\": 1048576,\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 294,\n \"copy_read_bytes\": 294,\n \"copy_sha256\": \"83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679\",\n \"copy_write_bytes\": 294,\n \"hashed_bytes\": 294,\n \"sha256\": \"83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679\"\n }\n },\n \"largest_batch_bytes\": 63,\n \"phase\": \"complete\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/depth-30/candidate/.serialization-s9j74p32\",\n \"status\": \"BOUNDED_SERIALIZATION_PASS\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"depth-33\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"circular\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"callback-list\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"callback-dict\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"callback-error\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"int-subclass\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"unsupported-object\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"malformed-result\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"malformed-witness\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"malformed-rank\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"nonstring-supported-keys\",\n \"operation\": {\n \"status\": \"LITERAL_REFERENCE_FALLBACK\"\n },\n \"outcome\": \"return\"\n },\n {\n \"case\": \"expected-result_sha256\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-result_sha256/candidate/.serialization-irfdvxp5\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-exact_witness_sha256\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-exact_witness_sha256/candidate/.serialization-bayv8dm8\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-rank_trace_sha256\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-rank_trace_sha256/candidate/.serialization-lgohmytl\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-rank_call_count\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-rank_call_count/candidate/.serialization-6iru0msf\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"expected-rank_distinct_matrix_count\",\n \"operation\": {\n \"batch_bytes_limit\": 1048576,\n \"batch_count\": 10,\n \"batch_rows_limit\": 1024,\n \"cleanup\": [],\n \"copy_bytes_limit\": 1048576,\n \"error\": {\n \"message\": \"Complete output, ordered witness, or rank trace changed from the frozen profile\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"expected_receipt\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-rank_distinct_matrix_count/candidate/.serialization-e3fsuup4\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": \"error\"\n },\n {\n \"case\": \"failure-stage_create\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {},\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage_create\",\n \"stage\": null,\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_open\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 0,\n \"retained_stage_stat_bytes\": null\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_open/.serialization-sf2f1r8u\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_write\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_write/.serialization-dttmsh4n\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_flush\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_flush/.serialization-3b9sydjn\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_after_close\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_after_close/.serialization-bgzyke8u\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-stage_hash\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 0,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_hash/.serialization-i13ho2fx\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_open-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_open-result.json/.serialization-ckzera8h\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_write-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_write-result.json/.serialization-vs7bqoew\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_flush-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_flush-result.json/.serialization-chcumbdy\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_after_close-result.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_after_close-result.json/.serialization-dt6qjc3w\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_open-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_open-witness.json/.serialization-6lz9b3k6\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_write-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_write-witness.json/.serialization-af3oy_81\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_flush-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_flush-witness.json/.serialization-hgwn2vaz\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_after_close-witness.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_after_close-witness.json/.serialization-9stya2bu\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_open-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_open-rank-trace.json/.serialization-j4p7xg5e\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_write-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_write-rank-trace.json/.serialization-uiqxk44f\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_flush-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_flush-rank-trace.json/.serialization-o7jbu6fl\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"failure-final_after_close-rank-trace.json\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:rank-trace.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_after_close-rank-trace.json/.serialization-jbq98uxn\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"short-final-0\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Short final write; no retry\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/short-final-0/.serialization-qbvs4u21\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"Short final write; no retry\"\n ]\n },\n {\n \"case\": \"short-final-1\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Short final write; no retry\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/short-final-1/.serialization-d94i7yv0\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"Short final write; no retry\"\n ]\n },\n {\n \"case\": \"copy-corrupt-content\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Staged copy digest or byte count changed\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/copy-corrupt-content/.serialization-db6glzv1\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Staged copy digest or byte count changed\"\n ]\n },\n {\n \"case\": \"stage-mutated-size\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"Staged artifact changed before copy\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 243,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/stage-mutated-size/.serialization-edskirpy\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Staged artifact changed before copy\"\n ]\n },\n {\n \"case\": \"copy-read-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/copy-read-error/.serialization-is0x9p9v\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"copy-hash-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 31,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"copy:witness.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/copy-hash-error/.serialization-5wvk5eju\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"cleanup-unlink-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\"\n ],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"cleanup\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/cleanup-unlink-error/.serialization-j3c6hi7s\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"cleanup-rmdir-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [\n \"result.json\",\n \"witness.json\",\n \"rank-trace.json\"\n ],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"injected IO failure\",\n \"type\": \"OSError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": null,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"cleanup\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/cleanup-rmdir-error/.serialization-_eykpp4g\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"OSError\",\n \"injected IO failure\"\n ]\n },\n {\n \"case\": \"primary-plus-close-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"close_errors\": [\n {\n \"phase\": \"stage\",\n \"type\": \"OSError\"\n }\n ],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"primary write failure\",\n \"type\": \"ValueError\"\n },\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/primary-plus-close-error/.serialization-k_fiklqe\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"ValueError\",\n \"primary write failure\"\n ]\n },\n {\n \"case\": \"primary-plus-manifest-error\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 0,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"primary write failure\",\n \"type\": \"ValueError\"\n },\n \"failure_manifest_error_type\": \"OSError\",\n \"files\": {\n \"result.json\": {\n \"accepted_write_bytes\": 0,\n \"copy_read_bytes\": 0,\n \"copy_write_bytes\": 0,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 0\n }\n },\n \"largest_batch_bytes\": 0,\n \"phase\": \"stage:result.json\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/primary-plus-manifest-error/.serialization-6coogccw\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"ValueError\",\n \"primary write failure\"\n ]\n },\n {\n \"case\": \"drift-reference_global\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Serializer effective global/builtin changed: canonical\"\n ]\n },\n {\n \"case\": \"drift-json_default\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON encoder binding changed: default\"\n ]\n },\n {\n \"case\": \"drift-expected_value\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Expected serializer receipt changed\"\n ]\n },\n {\n \"case\": \"drift-effective_builtin\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Serializer effective global/builtin changed: len\"\n ]\n },\n {\n \"case\": \"drift-json_global_shadow\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Serializer effective global/builtin changed: str\"\n ]\n },\n {\n \"case\": \"drift-keyword_default\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON keyword default changed\"\n ]\n },\n {\n \"case\": \"exit-json-drift\",\n \"operation\": {\n \"batch_bytes_limit\": 2048,\n \"batch_count\": 10,\n \"batch_rows_limit\": 3,\n \"cleanup\": [],\n \"copy_bytes_limit\": 31,\n \"error\": {\n \"message\": \"JSON encoder binding changed: default\",\n \"type\": \"RuntimeError\"\n },\n \"files\": {\n \"rank-trace.json\": {\n \"accepted_write_bytes\": 29,\n \"copy_read_bytes\": 29,\n \"copy_sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\n \"copy_write_bytes\": 29,\n \"hashed_bytes\": 29,\n \"retained_stage_stat_bytes\": 29,\n \"sha256\": \"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"\n },\n \"result.json\": {\n \"accepted_write_bytes\": 22,\n \"copy_read_bytes\": 22,\n \"copy_sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\n \"copy_write_bytes\": 22,\n \"hashed_bytes\": 22,\n \"retained_stage_stat_bytes\": 22,\n \"sha256\": \"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"\n },\n \"witness.json\": {\n \"accepted_write_bytes\": 242,\n \"copy_read_bytes\": 242,\n \"copy_sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\n \"copy_write_bytes\": 242,\n \"hashed_bytes\": 242,\n \"retained_stage_stat_bytes\": 242,\n \"sha256\": \"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"\n }\n },\n \"largest_batch_bytes\": 29,\n \"phase\": \"precleanup_freshness\",\n \"stage\": \"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/exit-json-drift/.serialization-iznl5z0r\",\n \"status\": \"FAILED_EVIDENCE_RETAINED\"\n },\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON encoder binding changed: default\"\n ]\n },\n {\n \"case\": \"fallback-exit-json-drift\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"JSON encoder binding changed: default\"\n ]\n },\n {\n \"case\": \"existing-finals\",\n \"outcome\": \"return\"\n },\n {\n \"case\": \"state-mutation-between-writes\",\n \"outcome\": [\n \"error\",\n \"RuntimeError\",\n \"Complete output, ordered witness, or rank trace changed from the frozen profile\"\n ]\n },\n {\n \"case\": \"path-subclass-fallback\",\n \"outcome\": \"return\"\n }\n ],\n \"optimization\": 0,\n \"retained_byte_cap\": 16777216,\n \"retained_bytes\": 132467,\n \"scope\": \"Finite exact-schema/unsupported/reference/regular-file controls; no full caller or performance claim\",\n \"status\": \"SERIALIZATION_FINITE_PASS\"\n}\n" + }, + { + "bytes": 1280, + "path": "science/component/copy-corrupt-content/.serialization-db6glzv1/failure.json", + "sha256": "465ffe1402a4b5332b00e79ad4e217cb946606fdad8b5bcf859124622f4204c8", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Staged copy digest or byte count changed\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/copy-corrupt-content/.serialization-db6glzv1\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/copy-corrupt-content/.serialization-db6glzv1/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/copy-corrupt-content/.serialization-db6glzv1/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-corrupt-content/.serialization-db6glzv1/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/copy-corrupt-content/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-corrupt-content/witness.json", + "sha256": "35a69d4f98a971b2463cfc889f102884891ccf2a76b94441b1ce36fb54a68c1e", + "utf8": "z\"active\":[1,2],\"args\":[null,[0-1]],\"code\":{\"gates\":[[1,[0],[1-2]]],\"outputs\":[[1,2],[0,1]],\"soles\":3,\"sources\":[[[2,1,0],1]-[[0,1,2],2]]},\"kind\":[null,\"in#],\"labels\":[[1,[[2,3],[0,1]],2-[1,3]]],\"pieces\":[[[0,1,2],2,[0,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1246, + "path": "science/component/copy-hash-error/.serialization-5wvk5eju/failure.json", + "sha256": "c4f19102dfbc6229aff92d0d7e45d7add3c9f8c30a68f9fcc6819e95d227d04f", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/copy-hash-error/.serialization-5wvk5eju\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/copy-hash-error/.serialization-5wvk5eju/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/copy-hash-error/.serialization-5wvk5eju/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-hash-error/.serialization-5wvk5eju/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/copy-hash-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/copy-hash-error/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 1245, + "path": "science/component/copy-read-error/.serialization-is0x9p9v/failure.json", + "sha256": "09dfe06d6b5226e726e6d6d71413b413e0ca47ed6bc8d425f248f96a8508f4d2", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/copy-read-error/.serialization-is0x9p9v\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/copy-read-error/.serialization-is0x9p9v/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/copy-read-error/.serialization-is0x9p9v/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/copy-read-error/.serialization-is0x9p9v/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/copy-read-error/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/copy-read-error/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 29, + "path": "science/component/depth-30/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-30/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 294, + "path": "science/component/depth-30/candidate/witness.json", + "sha256": "83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/depth-30/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-30/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 294, + "path": "science/component/depth-30/original/witness.json", + "sha256": "83e4fbb2e1d64f3e88c2a5aa56322951e761b3a3b42316d8d447a1b72313f679", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/depth-33/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-33/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 300, + "path": "science/component/depth-33/candidate/witness.json", + "sha256": "9606b4a94c188fff0f9f7f210ece8b8899dab46eb68fc89ecda75f5d4a58ab2a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/depth-33/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/depth-33/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 300, + "path": "science/component/depth-33/original/witness.json", + "sha256": "9606b4a94c188fff0f9f7f210ece8b8899dab46eb68fc89ecda75f5d4a58ab2a", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[1]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 2, + "path": "science/component/empty/candidate/rank-trace.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "utf8": "[]" + }, + { + "bytes": 22, + "path": "science/component/empty/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 126, + "path": "science/component/empty/candidate/witness.json", + "sha256": "34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405", + "utf8": "{\"active\":[],\"args\":[],\"code\":{\"gates\":[],\"outputs\":[],\"roles\":0,\"sources\":[]},\"kind\":[],\"labels\":[],\"pieces\":[],\"support\":[]}" + }, + { + "bytes": 2, + "path": "science/component/empty/original/rank-trace.json", + "sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945", + "utf8": "[]" + }, + { + "bytes": 22, + "path": "science/component/empty/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 126, + "path": "science/component/empty/original/witness.json", + "sha256": "34260256a691a44938d12da5b398095616795d66b38d88f8e67e10f2412e6405", + "utf8": "{\"active\":[],\"args\":[],\"code\":{\"gates\":[],\"outputs\":[],\"roles\":0,\"sources\":[]},\"kind\":[],\"labels\":[],\"pieces\":[],\"support\":[]}" + }, + { + "bytes": 29, + "path": "science/component/existing-finals/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/existing-finals/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/existing-finals/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/existing-finals-reference/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/existing-finals-reference/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/existing-finals-reference/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1439, + "path": "science/component/exit-json-drift/.serialization-iznl5z0r/failure.json", + "sha256": "c4dadbed4414d4c152fb7b350e747cddb18079bc5162fc0e490e8f9807f69063", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"JSON encoder binding changed: default\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\",\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"precleanup_freshness\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/exit-json-drift/.serialization-iznl5z0r\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/exit-json-drift/.serialization-iznl5z0r/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/exit-json-drift/.serialization-iznl5z0r/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/exit-json-drift/.serialization-iznl5z0r/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/exit-json-drift/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/exit-json-drift/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/exit-json-drift/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1261, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-bayv8dm8/failure.json", + "sha256": "0c3d0fc193ffacd17b2f75ca5c225dff864b3713e0e26e95f0f3bd7fb70b1d02", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-exact_witness_sha256/candidate/.serialization-bayv8dm8\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-bayv8dm8/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-bayv8dm8/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-exact_witness_sha256/candidate/.serialization-bayv8dm8/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1256, + "path": "science/component/expected-rank_call_count/candidate/.serialization-6iru0msf/failure.json", + "sha256": "59536202df9a86f5cfb44f5495d6787545313ec63bc6c14f6b8415cd0e2dd468", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-rank_call_count/candidate/.serialization-6iru0msf\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-rank_call_count/candidate/.serialization-6iru0msf/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-rank_call_count/candidate/.serialization-6iru0msf/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-rank_call_count/candidate/.serialization-6iru0msf/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1267, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-e3fsuup4/failure.json", + "sha256": "ccab174d22da2310ec3c60703d5af431932b46d34e5c0ce10534dc8015631226", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-rank_distinct_matrix_count/candidate/.serialization-e3fsuup4\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-e3fsuup4/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-e3fsuup4/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-rank_distinct_matrix_count/candidate/.serialization-e3fsuup4/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1258, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-lgohmytl/failure.json", + "sha256": "9e414ab78f5b20749e8910dbe523e351fa807876ee712322143bfb6e926596ca", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-rank_trace_sha256/candidate/.serialization-lgohmytl\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-lgohmytl/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-lgohmytl/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-rank_trace_sha256/candidate/.serialization-lgohmytl/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1254, + "path": "science/component/expected-result_sha256/candidate/.serialization-irfdvxp5/failure.json", + "sha256": "810cd68d9f5ff3e2a02799a3de00ca4b02eb29985fe2abe1509563d05d9e62a8", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/expected-result_sha256/candidate/.serialization-irfdvxp5\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/expected-result_sha256/candidate/.serialization-irfdvxp5/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/expected-result_sha256/candidate/.serialization-irfdvxp5/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/expected-result_sha256/candidate/.serialization-irfdvxp5/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1361, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-jbq98uxn/failure.json", + "sha256": "b19d1641246362c482206d6edc86f347a2a6f83b1c14be22ec87beb3f825204b", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_after_close-rank-trace.json/.serialization-jbq98uxn\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-jbq98uxn/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-jbq98uxn/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-rank-trace.json/.serialization-jbq98uxn/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-rank-trace.json/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1185, + "path": "science/component/failure-final_after_close-result.json/.serialization-dt6qjc3w/failure.json", + "sha256": "5607fc996aaeb93a4e94a502e8a0d246afadca9f959ba0b852dc549a26dc719f", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_after_close-result.json/.serialization-dt6qjc3w\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-result.json/.serialization-dt6qjc3w/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-result.json/.serialization-dt6qjc3w/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-result.json/.serialization-dt6qjc3w/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-result.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1272, + "path": "science/component/failure-final_after_close-witness.json/.serialization-9stya2bu/failure.json", + "sha256": "2e69ac8cc13bcae210f69a750eee838f1d352b01508a12f6808ada3cb57b51c2", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_after_close-witness.json/.serialization-9stya2bu\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_after_close-witness.json/.serialization-9stya2bu/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-witness.json/.serialization-9stya2bu/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-witness.json/.serialization-9stya2bu/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_after_close-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_after_close-witness.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1355, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-o7jbu6fl/failure.json", + "sha256": "c6558f6914a37907a4fe90ac006ebbaeb9016c4866907b2a8da939ac7888ce9a", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_write_bytes\":29,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_flush-rank-trace.json/.serialization-o7jbu6fl\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-o7jbu6fl/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-o7jbu6fl/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-rank-trace.json/.serialization-o7jbu6fl/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-rank-trace.json/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1179, + "path": "science/component/failure-final_flush-result.json/.serialization-chcumbdy/failure.json", + "sha256": "d0cfd53baa97b8fafa5199ac36569a6759e90c1491a4be9a4fe9316d320183bf", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_flush-result.json/.serialization-chcumbdy\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-result.json/.serialization-chcumbdy/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-result.json/.serialization-chcumbdy/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-result.json/.serialization-chcumbdy/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-result.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1266, + "path": "science/component/failure-final_flush-witness.json/.serialization-hgwn2vaz/failure.json", + "sha256": "870d36c0766c7133dcb1f060d9806cdbb502061c77e34c1f08e2d5cf43f9da28", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_flush-witness.json/.serialization-hgwn2vaz\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_flush-witness.json/.serialization-hgwn2vaz/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-witness.json/.serialization-hgwn2vaz/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-witness.json/.serialization-hgwn2vaz/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_flush-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_flush-witness.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1352, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-j4p7xg5e/failure.json", + "sha256": "9945491a6d54b73aefa7472e2b42fed9767e5317b9bd8873f26511ed16f09b9f", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_open-rank-trace.json/.serialization-j4p7xg5e\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-j4p7xg5e/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-j4p7xg5e/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-rank-trace.json/.serialization-j4p7xg5e/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1176, + "path": "science/component/failure-final_open-result.json/.serialization-ckzera8h/failure.json", + "sha256": "5a1eda26e8893541842f453024467455d69dfd6fb4d7446e110cec5fcf099fbd", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_open-result.json/.serialization-ckzera8h\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_open-result.json/.serialization-ckzera8h/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-result.json/.serialization-ckzera8h/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-result.json/.serialization-ckzera8h/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1261, + "path": "science/component/failure-final_open-witness.json/.serialization-6lz9b3k6/failure.json", + "sha256": "5fc728d7f859fe0696aa10b03b092fccb4b7f0bbebd143728e4ae8292843866e", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_open-witness.json/.serialization-6lz9b3k6\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_open-witness.json/.serialization-6lz9b3k6/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-witness.json/.serialization-6lz9b3k6/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_open-witness.json/.serialization-6lz9b3k6/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_open-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1354, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-uiqxk44f/failure.json", + "sha256": "204b9a02181d2d1e37f8ffa2adc9493355f1258bd3e788f0f8c4715969d6b3a2", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":29,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":242,\"copy_sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\",\"copy_write_bytes\":242,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:rank-trace.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_write-rank-trace.json/.serialization-uiqxk44f\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-uiqxk44f/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-uiqxk44f/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-rank-trace.json/.serialization-uiqxk44f/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 0, + "path": "science/component/failure-final_write-rank-trace.json/rank-trace.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-rank-trace.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-rank-trace.json/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 1178, + "path": "science/component/failure-final_write-result.json/.serialization-vs7bqoew/failure.json", + "sha256": "f5cf796da686a703f8291fb1f9fbaf989392a9b3493302fbb14018f0dd243898", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_write-result.json/.serialization-vs7bqoew\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_write-result.json/.serialization-vs7bqoew/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-result.json/.serialization-vs7bqoew/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-result.json/.serialization-vs7bqoew/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 0, + "path": "science/component/failure-final_write-result.json/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 1263, + "path": "science/component/failure-final_write-witness.json/.serialization-af3oy_81/failure.json", + "sha256": "2a4c818c0d96a7c1fb3d33c895c31c8314b8725a36654faf297a8bb5077b7301", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-final_write-witness.json/.serialization-af3oy_81\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/failure-final_write-witness.json/.serialization-af3oy_81/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-witness.json/.serialization-af3oy_81/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/failure-final_write-witness.json/.serialization-af3oy_81/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/failure-final_write-witness.json/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/failure-final_write-witness.json/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 670, + "path": "science/component/failure-stage_after_close/.serialization-bgzyke8u/failure.json", + "sha256": "420169b2162034fb3717aa9c0f5a92815fa79ec488373e5f1040199a1e05de35", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_after_close/.serialization-bgzyke8u\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 22, + "path": "science/component/failure-stage_after_close/.serialization-bgzyke8u/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 664, + "path": "science/component/failure-stage_flush/.serialization-3b9sydjn/failure.json", + "sha256": "f3a445d8085fcbe291e5b1a6eefc172956ce8347c62020c4e136ec680897d532", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_flush/.serialization-3b9sydjn\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 22, + "path": "science/component/failure-stage_flush/.serialization-3b9sydjn/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 660, + "path": "science/component/failure-stage_hash/.serialization-i13ho2fx/failure.json", + "sha256": "f1b8f9d7914762bb54e8e6c34ed28725ef663ce908ed3d80bf88844cfdb323f6", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":0,\"retained_stage_stat_bytes\":0}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_hash/.serialization-i13ho2fx\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 0, + "path": "science/component/failure-stage_hash/.serialization-i13ho2fx/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 663, + "path": "science/component/failure-stage_open/.serialization-sf2f1r8u/failure.json", + "sha256": "916e2c3fec457b5b0463dca64ff20a6cb6948768415062a8bfa847a5fe526685", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":0,\"retained_stage_stat_bytes\":null}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_open/.serialization-sf2f1r8u\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 662, + "path": "science/component/failure-stage_write/.serialization-dttmsh4n/failure.json", + "sha256": "09b77fa225d10a4ca07d7998324e0cda447950d505e48c1c0f6e51e55a737f2b", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"injected IO failure\",\"type\":\"OSError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":0}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/failure-stage_write/.serialization-dttmsh4n\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 0, + "path": "science/component/failure-stage_write/.serialization-dttmsh4n/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 29, + "path": "science/component/fallback-exit-json-drift/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/fallback-exit-json-drift/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/fallback-exit-json-drift/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/int-subclass/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/int-subclass/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/int-subclass/candidate/witness.json", + "sha256": "273eda2074ac0c67d1585cf11893cc6fd58e9fc3273b6efb9ad4de31a9de3d9c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[7]}" + }, + { + "bytes": 29, + "path": "science/component/int-subclass/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/int-subclass/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/int-subclass/original/witness.json", + "sha256": "273eda2074ac0c67d1585cf11893cc6fd58e9fc3273b6efb9ad4de31a9de3d9c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[7]}" + }, + { + "bytes": 37, + "path": "science/component/interned-rank-rows/candidate/rank-trace.json", + "sha256": "28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2", + "utf8": "[[[1,2,3],2],[[1,2,3],1],[[1,2,3],2]]" + }, + { + "bytes": 22, + "path": "science/component/interned-rank-rows/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/interned-rank-rows/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 37, + "path": "science/component/interned-rank-rows/original/rank-trace.json", + "sha256": "28344097a0dac3452286528f61759ef2b3005045f9c9a50a4109f409c92e29c2", + "utf8": "[[[1,2,3],2],[[1,2,3],1],[[1,2,3],2]]" + }, + { + "bytes": 22, + "path": "science/component/interned-rank-rows/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/interned-rank-rows/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/nonstring-supported-keys/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 17, + "path": "science/component/nonstring-supported-keys/candidate/result.json", + "sha256": "a71fc868af5e004c2efbfdf16bb2b679c348f2e25065b30b06df846eb32074a5", + "utf8": "{\"1\":\"a\",\"2\":\"b\"}" + }, + { + "bytes": 242, + "path": "science/component/nonstring-supported-keys/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/nonstring-supported-keys/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 17, + "path": "science/component/nonstring-supported-keys/original/result.json", + "sha256": "a71fc868af5e004c2efbfdf16bb2b679c348f2e25065b30b06df846eb32074a5", + "utf8": "{\"1\":\"a\",\"2\":\"b\"}" + }, + { + "bytes": 242, + "path": "science/component/nonstring-supported-keys/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/ordinary/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/ordinary/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/ordinary/candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/ordinary/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/ordinary/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/ordinary/original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/path-candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/path-candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/path-candidate/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 29, + "path": "science/component/path-original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/path-original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/path-original/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 724, + "path": "science/component/primary-plus-close-error/.serialization-k_fiklqe/failure.json", + "sha256": "adb173ec0a0c00a1e5986c6987b26d318397c4b42e2b00380ba38c53691dea73", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":0,\"batch_rows_limit\":3,\"cleanup\":[],\"close_errors\":[{\"phase\":\"stage\",\"type\":\"OSError\"}],\"copy_bytes_limit\":31,\"error\":{\"message\":\"primary write failure\",\"type\":\"ValueError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":0,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":0}},\"largest_batch_bytes\":0,\"phase\":\"stage:result.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/primary-plus-close-error/.serialization-k_fiklqe\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 0, + "path": "science/component/primary-plus-close-error/.serialization-k_fiklqe/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 0, + "path": "science/component/primary-plus-manifest-error/.serialization-6coogccw/result.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 29, + "path": "science/component/rows-1/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/rows-1/candidate/witness.json", + "sha256": "02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 238, + "path": "science/component/rows-1/original/witness.json", + "sha256": "02b4a816e2ea4035835e3ba87e05146a5b5184eaa54584944261b0bb57a60443", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1023/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1023/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4241, + "path": "science/component/rows-1023/candidate/witness.json", + "sha256": "d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1023/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1023/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4241, + "path": "science/component/rows-1023/original/witness.json", + "sha256": "d076ff96e005c928132016649474fc322c682a784b8c50497a1f451e78505143", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1024/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1024/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4246, + "path": "science/component/rows-1024/candidate/witness.json", + "sha256": "356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1024/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1024/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4246, + "path": "science/component/rows-1024/original/witness.json", + "sha256": "356d2293fd0ec2efa2ef0a0e35b8788cf85b0946345491f6018e3b51425de283", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1025/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1025/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4251, + "path": "science/component/rows-1025/candidate/witness.json", + "sha256": "cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024]}" + }, + { + "bytes": 29, + "path": "science/component/rows-1025/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-1025/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 4251, + "path": "science/component/rows-1025/original/witness.json", + "sha256": "cbafa9435a87541785ae9552ee995827297d39faefca84f0be653d80a5deebe4", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024]}" + }, + { + "bytes": 29, + "path": "science/component/rows-2048/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-2048/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 9366, + "path": "science/component/rows-2048/candidate/witness.json", + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047]}" + }, + { + "bytes": 29, + "path": "science/component/rows-2048/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/rows-2048/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 9366, + "path": "science/component/rows-2048/original/witness.json", + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499,500,501,502,503,504,505,506,507,508,509,510,511,512,513,514,515,516,517,518,519,520,521,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,538,539,540,541,542,543,544,545,546,547,548,549,550,551,552,553,554,555,556,557,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,575,576,577,578,579,580,581,582,583,584,585,586,587,588,589,590,591,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,608,609,610,611,612,613,614,615,616,617,618,619,620,621,622,623,624,625,626,627,628,629,630,631,632,633,634,635,636,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,655,656,657,658,659,660,661,662,663,664,665,666,667,668,669,670,671,672,673,674,675,676,677,678,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,694,695,696,697,698,699,700,701,702,703,704,705,706,707,708,709,710,711,712,713,714,715,716,717,718,719,720,721,722,723,724,725,726,727,728,729,730,731,732,733,734,735,736,737,738,739,740,741,742,743,744,745,746,747,748,749,750,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,790,791,792,793,794,795,796,797,798,799,800,801,802,803,804,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,851,852,853,854,855,856,857,858,859,860,861,862,863,864,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,889,890,891,892,893,894,895,896,897,898,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,916,917,918,919,920,921,922,923,924,925,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,941,942,943,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,959,960,961,962,963,964,965,966,967,968,969,970,971,972,973,974,975,976,977,978,979,980,981,982,983,984,985,986,987,988,989,990,991,992,993,994,995,996,997,998,999,1000,1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1011,1012,1013,1014,1015,1016,1017,1018,1019,1020,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,1033,1034,1035,1036,1037,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,1048,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,1059,1060,1061,1062,1063,1064,1065,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,1080,1081,1082,1083,1084,1085,1086,1087,1088,1089,1090,1091,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,1105,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,1121,1122,1123,1124,1125,1126,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1137,1138,1139,1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1153,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1216,1217,1218,1219,1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,1238,1239,1240,1241,1242,1243,1244,1245,1246,1247,1248,1249,1250,1251,1252,1253,1254,1255,1256,1257,1258,1259,1260,1261,1262,1263,1264,1265,1266,1267,1268,1269,1270,1271,1272,1273,1274,1275,1276,1277,1278,1279,1280,1281,1282,1283,1284,1285,1286,1287,1288,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,1299,1300,1301,1302,1303,1304,1305,1306,1307,1308,1309,1310,1311,1312,1313,1314,1315,1316,1317,1318,1319,1320,1321,1322,1323,1324,1325,1326,1327,1328,1329,1330,1331,1332,1333,1334,1335,1336,1337,1338,1339,1340,1341,1342,1343,1344,1345,1346,1347,1348,1349,1350,1351,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,1366,1367,1368,1369,1370,1371,1372,1373,1374,1375,1376,1377,1378,1379,1380,1381,1382,1383,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,1395,1396,1397,1398,1399,1400,1401,1402,1403,1404,1405,1406,1407,1408,1409,1410,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,1421,1422,1423,1424,1425,1426,1427,1428,1429,1430,1431,1432,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,1447,1448,1449,1450,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,1462,1463,1464,1465,1466,1467,1468,1469,1470,1471,1472,1473,1474,1475,1476,1477,1478,1479,1480,1481,1482,1483,1484,1485,1486,1487,1488,1489,1490,1491,1492,1493,1494,1495,1496,1497,1498,1499,1500,1501,1502,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,1514,1515,1516,1517,1518,1519,1520,1521,1522,1523,1524,1525,1526,1527,1528,1529,1530,1531,1532,1533,1534,1535,1536,1537,1538,1539,1540,1541,1542,1543,1544,1545,1546,1547,1548,1549,1550,1551,1552,1553,1554,1555,1556,1557,1558,1559,1560,1561,1562,1563,1564,1565,1566,1567,1568,1569,1570,1571,1572,1573,1574,1575,1576,1577,1578,1579,1580,1581,1582,1583,1584,1585,1586,1587,1588,1589,1590,1591,1592,1593,1594,1595,1596,1597,1598,1599,1600,1601,1602,1603,1604,1605,1606,1607,1608,1609,1610,1611,1612,1613,1614,1615,1616,1617,1618,1619,1620,1621,1622,1623,1624,1625,1626,1627,1628,1629,1630,1631,1632,1633,1634,1635,1636,1637,1638,1639,1640,1641,1642,1643,1644,1645,1646,1647,1648,1649,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,1661,1662,1663,1664,1665,1666,1667,1668,1669,1670,1671,1672,1673,1674,1675,1676,1677,1678,1679,1680,1681,1682,1683,1684,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,1697,1698,1699,1700,1701,1702,1703,1704,1705,1706,1707,1708,1709,1710,1711,1712,1713,1714,1715,1716,1717,1718,1719,1720,1721,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,1739,1740,1741,1742,1743,1744,1745,1746,1747,1748,1749,1750,1751,1752,1753,1754,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,1767,1768,1769,1770,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,1781,1782,1783,1784,1785,1786,1787,1788,1789,1790,1791,1792,1793,1794,1795,1796,1797,1798,1799,1800,1801,1802,1803,1804,1805,1806,1807,1808,1809,1810,1811,1812,1813,1814,1815,1816,1817,1818,1819,1820,1821,1822,1823,1824,1825,1826,1827,1828,1829,1830,1831,1832,1833,1834,1835,1836,1837,1838,1839,1840,1841,1842,1843,1844,1845,1846,1847,1848,1849,1850,1851,1852,1853,1854,1855,1856,1857,1858,1859,1860,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,1871,1872,1873,1874,1875,1876,1877,1878,1879,1880,1881,1882,1883,1884,1885,1886,1887,1888,1889,1890,1891,1892,1893,1894,1895,1896,1897,1898,1899,1900,1901,1902,1903,1904,1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916,1917,1918,1919,1920,1921,1922,1923,1924,1925,1926,1927,1928,1929,1930,1931,1932,1933,1934,1935,1936,1937,1938,1939,1940,1941,1942,1943,1944,1945,1946,1947,1948,1949,1950,1951,1952,1953,1954,1955,1956,1957,1958,1959,1960,1961,1962,1963,1964,1965,1966,1967,1968,1969,1970,1971,1972,1973,1974,1975,1976,1977,1978,1979,1980,1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018,2019,2020,2021,2022,2023,2024,2025,2026,2027,2028,2029,2030,2031,2032,2033,2034,2035,2036,2037,2038,2039,2040,2041,2042,2043,2044,2045,2046,2047]}" + }, + { + "bytes": 29, + "path": "science/component/scalars-unicode-wide/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/scalars-unicode-wide/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1132, + "path": "science/component/scalars-unicode-wide/candidate/witness.json", + "sha256": "413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,true,false,0.0,-0.0,1.25,Infinity,-Infinity,NaN,\"\\\\\\\"\\b\\f\\n\\r\\t\\u0000\",\"\\u1234\\ud83d\\ude42\\ud800\\udfff\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,-1,9007199254740991,9007199254740992,18446744073709551615,18446744073709551616,-18446744073709551616,233878353180758339522999985846145153701620551470473491834203652732173515904946260341745278133995563398543833002737305755265667540290727766807493212876909875594659990525149511668584314541080529232920507339280366608543284100729323707744847529244028704375222828075048053441873066841431886770996808740827211603475038378174976712681510622226105042933701081639420796456625832053480792840170201978746863875653930536130692114534553508213773677543990855402845952690966422979996611285214472124176258420341690709615016875950078934740489536866665063730098188523517481467195831094846379597369859669346905433590926427903227017534401181934141410249481203446155011741023897916350226373873852700758028505317376]}" + }, + { + "bytes": 29, + "path": "science/component/scalars-unicode-wide/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/scalars-unicode-wide/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1132, + "path": "science/component/scalars-unicode-wide/original/witness.json", + "sha256": "413a984f551612975857fa959ab4ddaa948e8968536e56a2fbe392126aa8e918", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,true,false,0.0,-0.0,1.25,Infinity,-Infinity,NaN,\"\\\\\\\"\\b\\f\\n\\r\\t\\u0000\",\"\\u1234\\ud83d\\ude42\\ud800\\udfff\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,-1,9007199254740991,9007199254740992,18446744073709551615,18446744073709551616,-18446744073709551616,233878353180758339522999985846145153701620551470473491834203652732173515904946260341745278133995563398543833002737305755265667540290727766807493212876909875594659990525149511668584314541080529232920507339280366608543284100729323707744847529244028704375222828075048053441873066841431886770996808740827211603475038378174976712681510622226105042933701081639420796456625832053480792840170201978746863875653930536130692114534553508213773677543990855402845952690966422979996611285214472124176258420341690709615016875950078934740489536866665063730098188523517481467195831094846379597369859669346905433590926427903227017534401181934141410249481203446155011741023897916350226373873852700758028505317376]}" + }, + { + "bytes": 1252, + "path": "science/component/short-final-0/.serialization-qbvs4u21/failure.json", + "sha256": "a8a1d97d9fce74c1400d3c2c003c6db88b8b9a518d74779bf438f233d473ffef", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Short final write; no retry\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/short-final-0/.serialization-qbvs4u21\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/short-final-0/.serialization-qbvs4u21/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/short-final-0/.serialization-qbvs4u21/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/short-final-0/.serialization-qbvs4u21/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/short-final-0/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 0, + "path": "science/component/short-final-0/witness.json", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 1252, + "path": "science/component/short-final-1/.serialization-d94i7yv0/failure.json", + "sha256": "e46f300e076dda438e53e5361f39be32373dd35f8ec5b05b48e87a49a8b62c4d", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Short final write; no retry\",\"type\":\"OSError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":31,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":242,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/short-final-1/.serialization-d94i7yv0\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/short-final-1/.serialization-d94i7yv0/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/short-final-1/.serialization-d94i7yv0/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/short-final-1/.serialization-d94i7yv0/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 22, + "path": "science/component/short-final-1/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1, + "path": "science/component/short-final-1/witness.json", + "sha256": "021fb596db81e6d02bf3d2586ee3981fe519f275c0ac9ca76bbcf2ebb4097d96", + "utf8": "{" + }, + { + "bytes": 1269, + "path": "science/component/stage-mutated-size/.serialization-edskirpy/failure.json", + "sha256": "eab4f502adf4b3096ef530bf15dc58ba991c7e28a193c9ad7861dfa89b224a00", + "utf8": "{\"batch_bytes_limit\":2048,\"batch_count\":10,\"batch_rows_limit\":3,\"cleanup\":[],\"copy_bytes_limit\":31,\"error\":{\"message\":\"Staged artifact changed before copy\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":22,\"copy_sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\",\"copy_write_bytes\":22,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":242,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":242,\"retained_stage_stat_bytes\":243,\"sha256\":\"5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340\"}},\"largest_batch_bytes\":29,\"phase\":\"copy:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/stage-mutated-size/.serialization-edskirpy\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/stage-mutated-size/.serialization-edskirpy/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/stage-mutated-size/.serialization-edskirpy/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 243, + "path": "science/component/stage-mutated-size/.serialization-edskirpy/witness.json", + "sha256": "ee4528b047c1a5d1af09bda2e753f72b43e8f383ae4b1622512a77b16221af09", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]} " + }, + { + "bytes": 22, + "path": "science/component/stage-mutated-size/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 1235, + "path": "science/component/state-changed/.serialization-ghmpicnj/failure.json", + "sha256": "6de96ee41592c19007ce231a7b95423b019d755b23c8e3ad77ebeaeeff3e7264", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":10,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Complete output, ordered witness, or rank trace changed from the frozen profile\",\"type\":\"RuntimeError\"},\"files\":{\"rank-trace.json\":{\"accepted_write_bytes\":29,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":29,\"retained_stage_stat_bytes\":29,\"sha256\":\"1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe\"},\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":245,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":245,\"retained_stage_stat_bytes\":245,\"sha256\":\"62e057a3ce3c149ef913959ca856f161a9ad409efce043208223ef4b5fd98667\"}},\"largest_batch_bytes\":29,\"phase\":\"expected_receipt\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/state-changed/.serialization-ghmpicnj\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 29, + "path": "science/component/state-changed/.serialization-ghmpicnj/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/state-changed/.serialization-ghmpicnj/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 245, + "path": "science/component/state-changed/.serialization-ghmpicnj/witness.json", + "sha256": "62e057a3ce3c149ef913959ca856f161a9ad409efce043208223ef4b5fd98667", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3,99]}" + }, + { + "bytes": 29, + "path": "science/component/state-first/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/state-first/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 242, + "path": "science/component/state-first/witness.json", + "sha256": "5dddf0634d7eff08f59a5fdc8d48912c3e4aa87713fd187feada889c61b64340", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[0,1,3]}" + }, + { + "bytes": 996, + "path": "science/component/wide-digit-error/candidate/.serialization-a8hfjpxs/failure.json", + "sha256": "7cd3ca59afc11ced0ea5e87db2bac3ea2fe03f8453c333711067d04973b10ed7", + "utf8": "{\"batch_bytes_limit\":1048576,\"batch_count\":8,\"batch_rows_limit\":1024,\"cleanup\":[],\"copy_bytes_limit\":1048576,\"error\":{\"message\":\"Exceeds the limit (640 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit\",\"type\":\"ValueError\"},\"files\":{\"result.json\":{\"accepted_write_bytes\":22,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":22,\"retained_stage_stat_bytes\":22,\"sha256\":\"cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2\"},\"witness.json\":{\"accepted_write_bytes\":235,\"copy_read_bytes\":0,\"copy_write_bytes\":0,\"hashed_bytes\":235,\"retained_stage_stat_bytes\":235}},\"largest_batch_bytes\":27,\"phase\":\"stage:witness.json\",\"stage\":\"/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/wide-digit-error/candidate/.serialization-a8hfjpxs\",\"status\":\"FAILED_EVIDENCE_RETAINED\"}" + }, + { + "bytes": 22, + "path": "science/component/wide-digit-error/candidate/.serialization-a8hfjpxs/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 235, + "path": "science/component/wide-digit-error/candidate/.serialization-a8hfjpxs/witness.json", + "sha256": "f4967dabbd5244ab63f156add8d56454d67b1fdddc3ee5d032a17b1fc28a95a4", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[" + }, + { + "bytes": 29, + "path": "science/component/wide-unlimited/candidate/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/wide-unlimited/candidate/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 12281, + "path": "science/component/wide-unlimited/candidate/witness.json", + "sha256": "4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376,-398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376]}" + }, + { + "bytes": 29, + "path": "science/component/wide-unlimited/original/rank-trace.json", + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "utf8": "[[[1,2],2],[[1,2],1],[[2],1]]" + }, + { + "bytes": 22, + "path": "science/component/wide-unlimited/original/result.json", + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "utf8": "{\"number\":3,\"ok\":true}" + }, + { + "bytes": 12281, + "path": "science/component/wide-unlimited/original/witness.json", + "sha256": "4d00891f95ff89d3dc51030f1b692d13c38beb44a053e8e1989dde059793849c", + "utf8": "{\"active\":[1,2],\"args\":[null,[0,1]],\"code\":{\"gates\":[[1,[0],[1,2]]],\"outputs\":[[1,2],[0,1]],\"roles\":3,\"sources\":[[[2,1,0],1],[[0,1,2],2]]},\"kind\":[null,\"in\"],\"labels\":[[1,[[2,3],[0,1]],2,[1,3]]],\"pieces\":[[[0,1,2],2,[1,2]]],\"support\":[398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376,-398027684033796659235430720619120245370477278049242593871342686565238635974930057042676009749975595510836461137504912702831400376935319143621753470415827025981215282426893498224826615977707595539466961019588699726772279731941315198182787264034852821200164566127930390710398182979935327718016873784821349516406114982916691867361875370024545872140793827277482562824192439237801588697814168520338650090909697535966525032757049430286459482977357373598020450589927318365663076719136934132593126761906696003770385305284570331119691001526584347722012386381881779425549210851696458253943578557699072154639655630793883941961378971846841113804188730258903839103669626086974468150655710480841592465655211805257863007811676888839555017536731758113448656752514158601444051645154665514388431619042396106716755762338728183461369854648923972904427556158821823778729193111453445844216979095435045778144571378954652122396061615147642540250745857228893999875491625014946013839340891326060933901036249999238637827577774666644809734033861619420363936465178730919233673114244563915058438996625834112132967998495576249320462871747777012165543887156255858358784852335060574881876552025685704823768078710818951860741379429242110855644973977420413810373514584504006896392675854997866870818564207239083874324953871276375716101506575153205747363963740749867514682619756775534507006871485887812402927738227576635284174246988540785975240020481266853076127172228024330561550120182008777598230542033702463408316671120886169260934006805799864598636311179787776738608992346063063099659648279663878174074787179237169752957046404584525301384153358344055908219695854852185210739761460551596658211013159915409566145426809737550417578228465835830890294497535463112081537672664056891624345779311524560019984315456142126282898486728345004767873499752683471409587367450593302392307908004590644754012537113320493601682133709318222647489080531644015321391157387178232154126828007760313716872242209614200967522180475716199973689467714010404673961454146466045855232217196687665143147612199151921277432309700460321430381533385245877431330533479476152339364503436322919665631042328740463612565842560411947020174006507893396276103834436233140915025391014386119201176462659556388343058600326710618903683746516577021214276933289179021059956925949717956040857979165914170970056212869933593589268626151996676594370800885093048230687152803213254735594741799076039453057272319884322341883241036382617598401889439130301876975498681736174215711287053447013711596004574803562701388246822510391522419061320663740921321754344166744899588160649291823535983386025904942040724581017615968429577015808090360968544059204594200069304612417366398776831532265596224715750301792207725607932534543693758772262010387360435567635232718343420679693057360004073679493008945813961012439574397373178636054628207647520675194420244271036343729318858430871461978866964772362057290577326080664463129657590249859748544101333842092713653096656066266827446079145590196644643417403723220085696202719321533233027169599734928971588850348415000070034027025298183104148343980297663148971586607903771717880683175436445585810610546882073571556162324659351310326560804448974229349743425637164834242799991427145050899469511954834774847172360693568437689147399455672090773686782511054291185172381917008889957645311339950993044779783607140593766508017935992581357858306525303783231752425242008347844867988333025417249944092118578113687403158162707075154006053416374075765162668533127078605316562826337193606242535290683224423660462222408680300498714149607265550441220738075941633988435051594487256802874182264814425923111193188280632013127802897889605338783089532740877202304122498193625454768343775535498872821099981620497070810489137457106892573248498734243717184800822956334469415666818858073218653977954309023182851723246522042792401461382001601920501284439325214084210736400630884929942272982943613708123011355260915545831043160243523599372006226150289664982113944898886610710824955096724626895416484521819026132177640598691658035986285376355033719094568083122219345722063613609779158338084375331431276527548482566210071347744541292871876134764249704859840950276227627328897424208932988115108907187647698491814375639614313178092528678007370045871748218421786396197284213209022623762734630836006864192414605237248983289006905268988475197599781524158913583701325199090352274252608342971303907669363045656232183978755853064004010895030834921988601355201181158877254807798058635127708445592064519563115094749276606697559529332807221414021024905241788974917755034700510432039890197393691722911126889174394312127254793141624975830429097997705531781908242083922068769027355129212617244130640289994777413026624013157329948333586377955103195844817163822484232700763859290253400376515701986753596890075818544485475785780031843579065754095099970940504640212850809997051128976563880886392410766321449987529690463262182894272302749154535447233331028841215215533602398281107050696017507827602761547816324743297938177204183765821117818869959795031848201322436053103778993541384779857262311465895754085538371969040922420936915076653500310175006188572019017358300979056992161958286882575984331858170857303361269891312794369244896540323192451678830668180455059289743580640736076233561935888109525845803125912388965524166819855977061399043499229843517930169118036812460794615667808961600389778306540324849286501515292799391304510997298128228258006156017389878086272789993321416349205921635696963703558971391123174877353757536774013315034956942784403824181551741629180658414081905650333672638983416786388095026169496605199749691595798835947189777822765198767949699778106683862989103096006505865271003566346191382406011673958404009194852110016915222433459641787170917872140367871023596464051647947388580570774462304347896201676197195521428782313608583714399238092208362933211302942806480175589402387976531080436906856834377344137698180789562645974374155400497754843905032231188252125802180353577510519869570675234892321663406309376]}" + }, + { + "bytes": 0, + "path": "stderr.txt", + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", + "utf8": "" + }, + { + "bytes": 79, + "path": "stdout.txt", + "sha256": "1a0ef58a650559d0f38dba77eb5c9dacaeaa4a39405e04a38f3e420367a5220b", + "utf8": "{\"mode\": \"controls\", \"optimization\": 0, \"status\": \"FINITE_COMPONENT_RETURNED\"}\n" + }, + { + "bytes": 80, + "path": "usage.json", + "sha256": "87c140cfd7f28745cc3886b98b9062793c305e5331df642faba4b61ff23c6c9e", + "utf8": "{\"user_seconds\":0.30,\"system_seconds\":0.10,\"kernel_max_rss_kib\":22592,\"exit\":0}\n" + } + ], + "original_run_root": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal", + "schema": "verbatim-finite-run-bundle-v1", + "total_bytes": 237678 +} diff --git a/research/h25-bounded-serializer/validation/reviews/EXACT-OPERATION-REVIEW-v1.json b/research/h25-bounded-serializer/validation/reviews/EXACT-OPERATION-REVIEW-v1.json new file mode 100644 index 0000000000..336c14a030 --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/EXACT-OPERATION-REVIEW-v1.json @@ -0,0 +1,75 @@ +{ + "accepted_scope": "Exact four one-use bounded parent operations, assembled immutable stage, unchanged guard, launcher/environment/evidence custody and existing-budget reservation under trusted finite host assumptions. Parent remains sole execution/admission owner.", + "checks": { + "launchers": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LAUNCHER-PINS-v1.json", + "sha256": "51a09ea4c1fa9b46c3767b65ca93663584b6cb5ad8266a891da6a8ff98ead4da" + }, + "operations": [ + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-controls-normal" + }, + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-controls-O" + }, + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-baseline-2048" + }, + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-candidate-2048" + } + ], + "phase": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/EXECUTION-PHASE.json", + "sha256": "529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32" + }, + "runner": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + }, + "stage": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/STAGE.json", + "sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c" + } + }, + "conditions": [ + "Execute only exact four operations serially in order and at most once; parent records one-use admission and verifies these pins immediately before launch.", + "Reconcile every attempt outer GNU wall+2+.01 into existing63.770533479 usage; stop on first nonzero/timeout/unclosed/bad receipt/custody drift or independent rejection.", + "Use SIGINT117s+KILL3s outer timeout as pinned. Do not infer cleanup after interruption; retain/charge failed evidence and stop.", + "No target imports/tests/measurements by reviewer. Parent independently reads all70normal+70optimized names/modes and fresh full finite artifact equality/cost evidence.", + "Physical boundary remains OPEN_NOT_ZERO, including preparation/final publication residual and trusted responsive filesystem assumptions. No original fullH25/runtime/native/host attestation or scientific/performance gain is admitted." + ], + "created_utc": "2026-10-31T04:36:19.008306+00:00", + "defects": [ + "Earlier time evidence exists /usr/bin/timeout", + "Earlier time evidence exists /usr/bin/timeout", + "Earlier time evidence exists /usr/bin/timeout", + "Earlier time evidence exists /usr/bin/timeout" + ], + "disposition": "REJECT", + "execution_performed_by_reviewer": false, + "method": "Exact source/argv/manual inspection and ordinary metadata hashing only; no target execution or process inspection.", + "policy_reservation_prior_plus_four_seconds": "551.810533479", + "proposal": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/OPERATION-PROPOSAL-v2.json", + "sha256": "788cd8fbb6c0c9efc5402990fc6c58d17bf761d6d337c450d15a4f6cdc96e8ac" + }, + "runtime_result_qualification": false, + "schema": "serializer-independent-exact-operation-review-v1", + "stage_files": 26, + "stage_sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c", + "unchanged_guard_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/reviews/EXACT-OPERATION-REVIEW-v2.json b/research/h25-bounded-serializer/validation/reviews/EXACT-OPERATION-REVIEW-v2.json new file mode 100644 index 0000000000..0b860f398a --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/EXACT-OPERATION-REVIEW-v2.json @@ -0,0 +1,97 @@ +{ + "accepted_scope": "Exact four one-use bounded parent operations, assembled immutable stage, unchanged guard, launcher/environment/evidence custody and existing-budget reservation under trusted finite host assumptions. Parent remains sole execution/admission owner.", + "checks": { + "launchers": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/LAUNCHER-PINS-v1.json", + "sha256": "51a09ea4c1fa9b46c3767b65ca93663584b6cb5ad8266a891da6a8ff98ead4da" + }, + "operations": [ + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-controls-normal" + }, + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-controls-O" + }, + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-baseline-2048" + }, + { + "exact_argv_and_evidence_verified": true, + "fresh_output_paths": true, + "label": "serializer-candidate-2048" + } + ], + "phase": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/EXECUTION-PHASE.json", + "sha256": "529045f34245622f04babc5a765815d52adc09fbad330ce4e2dc885e9c016e32" + }, + "runner": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/run_guarded.py", + "sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a" + }, + "stage": { + "matches": true, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/STAGE.json", + "sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c" + } + }, + "conditions": [ + "Execute only exact four operations serially in order and at most once; parent records one-use admission and verifies these pins immediately before launch.", + "Reconcile every attempt outer GNU wall+2+.01 into existing63.770533479 usage; stop on first nonzero/timeout/unclosed/bad receipt/custody drift or independent rejection.", + "Use SIGINT117s+KILL3s outer timeout as pinned. Do not infer cleanup after interruption; retain/charge failed evidence and stop.", + "No target imports/tests/measurements by reviewer. Parent independently reads all70normal+70optimized names/modes and fresh full finite artifact equality/cost evidence.", + "Physical boundary remains OPEN_NOT_ZERO, including preparation/final publication residual and trusted responsive filesystem assumptions. No original fullH25/runtime/native/host attestation or scientific/performance gain is admitted." + ], + "created_utc": "2026-10-31T04:36:38.490020+00:00", + "defects": [], + "disposition": "ACCEPT_PARENT_MAY_ADMIT", + "execution_performed_by_reviewer": false, + "fresh_evidence_recheck": [ + { + "all_four_evidence_paths_fresh": true, + "label": "serializer-controls-normal", + "time_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt" + }, + { + "all_four_evidence_paths_fresh": true, + "label": "serializer-controls-O", + "time_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-O.time.txt" + }, + { + "all_four_evidence_paths_fresh": true, + "label": "serializer-baseline-2048", + "time_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-baseline-2048.time.txt" + }, + { + "all_four_evidence_paths_fresh": true, + "label": "serializer-candidate-2048", + "time_path": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-candidate-2048.time.txt" + } + ], + "method": "Exact source/argv/manual inspection and ordinary metadata hashing only; no target execution or process inspection.", + "policy_reservation_prior_plus_four_seconds": "551.810533479", + "predecessor_review": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/EXACT-OPERATION-REVIEW-v1.json", + "sha256": "f12543f6fa82580a702b119a9866c6b580f046035fa55a0deaeb5c6b9ba7aea2" + }, + "proposal": { + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/control/OPERATION-PROPOSAL-v2.json", + "sha256": "788cd8fbb6c0c9efc5402990fc6c58d17bf761d6d337c450d15a4f6cdc96e8ac" + }, + "reviewer_correction": "Prior reviewer metadata script used argv index11 (/usr/bin/timeout) instead of index10 (time output) for freshness check. This additive correction selects actual -o argument, checks all4 evidence paths per operation afresh and preserves original erroneous rejection. No authored/assembled source or proposal changed.", + "runtime_result_qualification": false, + "schema": "serializer-independent-exact-operation-review-v1", + "stage_files": 26, + "stage_sha256": "a01d0c1e17b137afeb98a2339558a51cd240c8bdbdccff3e715024d0b8e3704c", + "unchanged_guard_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/reviews/EXECUTION-REVIEW-FREEZE-v1.json b/research/h25-bounded-serializer/validation/reviews/EXECUTION-REVIEW-FREEZE-v1.json new file mode 100644 index 0000000000..bf61dae498 --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/EXECUTION-REVIEW-FREEZE-v1.json @@ -0,0 +1,33 @@ +{ + "files": { + "EXACT-OPERATION-REVIEW-v1.json": { + "bytes": 3991, + "mode": 292, + "sha256": "f12543f6fa82580a702b119a9866c6b580f046035fa55a0deaeb5c6b9ba7aea2" + }, + "EXACT-OPERATION-REVIEW-v2.json": { + "bytes": 5733, + "mode": 292, + "sha256": "8ecd22a37b18a569f462f0250938023b92975a030280e8efa75f5b3b20bc09c4" + }, + "EXECUTION-SOURCE-REVIEW-v1.json": { + "bytes": 4523, + "mode": 292, + "sha256": "714a014a1d561a2eabc5fa68528bbe406c1c738d03d01d0fb71682568633b8e7" + }, + "RUNTIME-METADATA-CHECK-v1.json": { + "bytes": 16060, + "mode": 292, + "sha256": "bceeb39e875ca42adc8e77e1b195b2f5e258a8cb8981a90c8afb2bb8046ed988" + } + }, + "frozen_utc": "2026-10-31T04:36:54.948521+00:00", + "governing_exact_operation_review": "EXACT-OPERATION-REVIEW-v2.json", + "prior_reviews_untouched": true, + "reviewer_correction_preserved": "v1 operation review had metadata argv-index error only; corrected additively in v2, no authored source change or target run.", + "reviewer_target_executions": 0, + "runtime_results_or_performance_admitted": false, + "schema": "serializer-additive-execution-review-freeze-v1", + "status": "ACCEPT_PARENT_MAY_ADMIT_EXACT_FOUR_ONE_USE_OPERATIONS", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/reviews/EXECUTION-SOURCE-REVIEW-v1.json b/research/h25-bounded-serializer/validation/reviews/EXECUTION-SOURCE-REVIEW-v1.json new file mode 100644 index 0000000000..eb45f3ae1b --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/EXECUTION-SOURCE-REVIEW-v1.json @@ -0,0 +1,72 @@ +{ + "accepted_scope": "Exact frozen finite execution adapter/JOBS/runtime anchor source only, under explicitly trusted finite host and source/runtime assumptions. Parent may assemble exact immutable stage and one-use command admissions. This is not launch permission.", + "accounting_and_timeout_requirements": [ + "Unchanged guard accepts phase600, not remaining536.x; fresh inner namespace creates no allowance.", + "Parent outer four-command reservation is4*(120+2+.01)=488.04; prior63.770533479 gives551.810533479<600. Reconcile actual outer GNU wall+2+.01 after every attempt.", + "Use timeout --signal=INT --kill-after=3s117s so Python guard can reach finally killpg/reap for its detached target group; default TERM provides no such cleanup.", + "Any timeout/error/unclosed receipt stops subsequent operations, retains/charges evidence and admits no cleanup claim without actual evidence.", + "Before/after hashes, local readbacks, guard logs, all independent validation and metadata publication costs remain in the bill; physical tail remains unknown." + ], + "created_utc": "2026-10-31T04:34:28.130243+00:00", + "current_runtime_file_metadata_count": 84, + "defects": [], + "disposition": "ACCEPT", + "finite_host_limitations": [ + "Recorded source/binary hashes and origins do not attest arbitrary host/process memory or cached bytecode independently; trusted parent finite-host/system-site/cached-bytecode assumptions remain explicit.", + "Outer INT cleanup has not been exercised; successful complete evidence required, and interruption can leave missing postcheck/receipt." + ], + "launch_admission": false, + "manifest_sha256": "014d5289caf48fa1f4bd8b63ad3ca98ddeb0205293c4955e7622840f1da8a672", + "method": "Source/manual review, AST and ordinary current file hashing only. No target imports/execution/tests/process inspection.", + "remaining_launch_gates": [ + "Exact copied unchanged run_guarded.py hash and complete immutable assembled STAGE inventory externally reviewed", + "Exact four command argv/cwd/env/fresh labels/stdout/stderr/time paths and one-use admissions independently reviewed", + "Parent current actual charged ledger and stop/no-retry policy upheld" + ], + "reviewed_payload_files": { + "INVENTORY-PROPOSED.json": { + "bytes": 2665, + "mode": 292, + "sha256": "963f076fe7167df374cf689c7cf8b0ed4b11031c3eb7f2f3f23c9b9313b4785b" + }, + "JOBS.json": { + "bytes": 497, + "mode": 292, + "sha256": "a17050cb103849e25861ba167076be0599ab5f6f37a1c2ed33b07e7728d3ea65" + }, + "README.md": { + "bytes": 3823, + "mode": 292, + "sha256": "b08ce8ec929e8dc8289b71fd80351476e74305bf82ffbdae9e51f4e1ea18445e" + }, + "RUNTIME-PINS.json": { + "bytes": 20275, + "mode": 292, + "sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c" + }, + "RUNTIME-PINS.sha256": { + "bytes": 65, + "mode": 292, + "sha256": "3f19eff68ec00a26632c5049950387ca94d5124dd11807f7fa0c81ee91abfc71" + }, + "integration/full_driver.py": { + "bytes": 8418, + "mode": 292, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + } + }, + "runtime_manifest_sha256": "841468baffb0a47cd1627d8cc091925168daa93cdc9dba695f7e887c6a69aa1c", + "runtime_or_performance_qualification": false, + "schema": "serializer-independent-execution-source-review-v1", + "source_findings": [ + "Adapter performs exact parent-anchored runtime and frozen package inventory/byte/mode checks before any target import and after successful return or primary exception.", + "Module origins restricted to actual adapter, four authenticated local modules and trusted parent runtime map; authenticated package path explicitly inserted under safe-path.", + "Six declared env values/startup flags plus absence of five forbidden Python vars required; version and real executable fixed.", + "Exactly four finite jobs preserve70normal+70optimized controls and baseline/candidate normal2048-row comparisons; no scientific lane.", + "Primary exception survives secondary postcheck or boundary writing failure; any postcheck or sole boundary write failure rejects success.", + "Pre/post hashing uses bounded1MiB regular-file reads with before/after descriptor/path identity; metadata reads capped1MiB.", + "Original helper/control/API failure semantics and full-H25 custody requirements remain preserved through exact package pin." + ], + "target_executions": 0, + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/reviews/FIRST-ATTEMPT-FAILURE-REVIEW-v1.json b/research/h25-bounded-serializer/validation/reviews/FIRST-ATTEMPT-FAILURE-REVIEW-v1.json new file mode 100644 index 0000000000..d2876b446c --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/FIRST-ATTEMPT-FAILURE-REVIEW-v1.json @@ -0,0 +1,92 @@ +{ + "F5_F6_F7": "UNQUALIFIED", + "all_checks_pass": true, + "checks": { + "boundary_primary_and_postcheck_error": true, + "guard_stop_exit1": true, + "retained_logs_stable": true, + "science_contains_boundary_only": true, + "source_custody_precedes_path_and_target_import": true, + "stage_and_guard_unchanged": true, + "stderr_hash_matches": true, + "traceback_before_import": true + }, + "classification": "Runtime manifest omitted resolved /etc/python3.12/sitecustomize.py from automatic system-site initialization. Current adapter correctly rejects unadmitted file-backed origin before local package path insertion or target import. This is a concrete runtime custody/admission defect, not a serializer/control logic failure.", + "counts": { + "baseline_candidate_comparisons": 0, + "control_runner_imports_or_calls": 0, + "controls_completed": 0, + "guard_adapter_attempts": 1, + "serializer_imports_or_calls": 0 + }, + "created_utc": "2026-10-31T04:40:48.806849+00:00", + "current_runtime_admission": "HELD_PENDING_DISTINCT_CORRECTED_STAGE_AND_INDEPENDENT_REVIEW", + "disposition": "CONFIRMED_FAIL_CLOSED_CUSTODY_PREIMPORT_STOP", + "evidence": { + "/etc/python3.12/sitecustomize.py": { + "bytes": 155, + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt": { + "bytes": 119, + "sha256": "d5d32f91891738afa592aefbe405c68ba8dcec1fffad66d5cc25d1063e5962b9" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/START.json": { + "bytes": 1073, + "sha256": "5a5cb57fd9ef2e8a3d8b9827cfb7e666d872f4dd215a1475f95396189b86f89e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/receipt.json": { + "bytes": 2108, + "sha256": "c5908920fefde3b20a25290f0b38b5dbd9fcd237cd73a51ad23ec7c50531ba2d" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/science/adapter-boundary.json": { + "bytes": 689, + "sha256": "233809ac78d99a4a087c485e325c8d77545ee6a05a4cf5d05b1d80aefe634d18" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/stderr.txt": { + "bytes": 1635, + "sha256": "59a2dddcb39107e516cec72edcb661cf9e22c54d62be0676634b8e4049e28ddf" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/stdout.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py": { + "bytes": 8418, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + } + }, + "measured_failure": { + "inner_runner_wall_seconds": 0.2644113269634545, + "inner_sampled_process_group_rss_bytes": 31526912, + "new_policy_seconds": "66.090533479", + "outer_GNU_max_rss_kib": "31504", + "outer_GNU_system_seconds": "0.04", + "outer_GNU_user_seconds": "0.25", + "outer_GNU_wall_seconds": "0.31", + "performance_disposition": "Failure/admission overhead only; no serializer timing/performance result.", + "policy_charge_seconds": "2.32", + "prior_policy_seconds": "63.770533479" + }, + "original_source_reviews": "F1/F2/F4 and execution-source exact-byte evidence preserved; no target source mutation identified.", + "physical_boundary": "OPEN_NOT_ZERO", + "repair_authorization_assessment": { + "authority": "PLAN-v1.md timeboxes item3 explicitly permits one repair pass capped15minutes inside implementation/review60minutes; direct user authorization remains limited to this stream.", + "conditions": [ + "Record repair start/deadline and single-pass consumption; preserve old stage/proposal/failed attempt and all charged costs.", + "Correct concrete runtime metadata closure by recording actual resolved sitecustomize path/hash/module origin; keep original target implementation/controls unchanged.", + "Use distinct new immutable stage/runtime manifest/proposal and fresh evidence labels; independently review exact new custody before parent creates one-use admission.", + "No automatic retry/reroll or same-stage reexecution; dispatch stays stopped until newly corrected admission.", + "Recalculate current total against existing initial600/total2400 and retain physicaltailunknown;4*122.01+66.090533479=554.130533479<600 is reservation arithmetic, not fresh allowance.", + "Stop on any subsequent error/unclosed result under the new fixed proposal; no further unapproved repair pass." + ], + "permitted_in_principle": true + }, + "retained_science_files": [ + "adapter-boundary.json" + ], + "reviewer_method": "Bounded retained new-attempt metadata/log/boundary reads, exact source ordering and ordinary metadata hashes only; no tests, target imports/execution or process inspection.", + "schema": "serializer-independent-first-attempt-failure-review-v1", + "whole_H25_qualification": false, + "zero_target_execution_basis": "Traceback identifies exact before-custody call; source ordering places every target import/call strictly after successful custody. Fresh science tree contains boundary failure record only. This inference retains the accepted trusted finite-host/nonhostile cached-bytecode assumptions; no claim of arbitrary host-memory attestation." +} diff --git a/research/h25-bounded-serializer/validation/reviews/PUBLIC-OUTCOME-v1.md b/research/h25-bounded-serializer/validation/reviews/PUBLIC-OUTCOME-v1.md new file mode 100644 index 0000000000..1ccc8cf141 --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/PUBLIC-OUTCOME-v1.md @@ -0,0 +1,14 @@ +The standalone bounded serializer passed all70 declared ordered controls in normal mode and all70 in optimized mode. An independent retained-evidence review accepted F5 and F6, checked the exact control order and modes, compared31 original/candidate file pairs in each mode, and verified the recorded successful cleanup and retained failure evidence. The earlier runtime-custody failure remains preserved and charged; the single corrected admission added the omitted system `sitecustomize` origin and used a distinct immutable stage. No test or timing was rerolled. + +The separately executed baseline and candidate finite consumers produced identical files:22-byte result,9,366-byte witness and29-byte rank trace,9,417bytes total. Both receipts retain three rank events and two distinct matrices. The candidate used the production bounded writer with eleven batches and a largest encoded batch of5,121bytes. Its operational record accounts for9,417bytes each of stage writes, copy reads and final writes, with18,834bytes of stage-plus-copy hash input. Common finite expected-value derivation and local/independent artifact readbacks are additional work. + +| Fixed operation | Outer wall seconds | Outer user+system CPU seconds | GNU peak RSS KiB | +|---|---:|---:|---:| +|70 normal controls|0.53|0.48|22,592| +|70 optimized controls|0.56|0.55|23,672| +|Baseline,2048 support rows|0.26|0.24|20,168| +|Candidate,2048 support rows|0.27|0.25|22,012| + +These are single fixed first observations, including guarded startup, runtime/source checks and the declared finite consumer. They show no saving. The candidate's recorded wall, CPU and peak RSS are higher; the rounded single samples do not establish a repeatable regression magnitude. The tiny finite fixture is not a full H25 performance proxy. + +The bounded comparison and explicit no-gain disposition are accepted. F7 remains partial because complete physical cost closure is still open: preparation, independent validation/readback and final metadata/publication tails are unmeasured and are not zero. Charged policy usage is75.750533479seconds under the existing budget; that policy total includes nominal administrative charges and is not a measured physical total. Complete H25 caller/artifact qualification, full-workload performance and the original six-area goal percentages remain unchanged. diff --git a/research/h25-bounded-serializer/validation/reviews/PUBLIC-OUTCOME-v2.md b/research/h25-bounded-serializer/validation/reviews/PUBLIC-OUTCOME-v2.md new file mode 100644 index 0000000000..48b51fed11 --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/PUBLIC-OUTCOME-v2.md @@ -0,0 +1,14 @@ +The standalone bounded serializer passed all 70 declared ordered controls in normal mode and all 70 in optimized mode. An independent retained-evidence review accepted F5 and F6, checked the exact control order and modes, compared 31 original/candidate case pairs in each mode, and verified the recorded successful cleanup and retained failure evidence. The earlier runtime custody failure remains preserved and charged; the single corrected admission added the omitted system `sitecustomize` origin and used a distinct immutable stage. No test or timing was rerolled. + +The separately executed baseline and candidate finite consumers produced identical files: a 22-byte result, a 9,366-byte witness and a 29-byte rank trace, totaling 9,417 bytes. Both receipts retain three rank events and two distinct matrices. The candidate used the production bounded writer with eleven batches and a largest encoded batch of 5,121 bytes. Its operational record accounts for 9,417 bytes each of stage writes, copy reads and final writes, with 18,834 bytes of stage-plus-copy hash input. Common finite expected-value derivation and local/independent artifact readbacks are additional work. + +| Fixed operation | Outer wall seconds | Outer user+system CPU seconds | GNU peak RSS KiB | +|---|---:|---:|---:| +| 70 normal controls | 0.53 | 0.48 | 22,592 | +| 70 optimized controls | 0.56 | 0.55 | 23,672 | +| Baseline, 2048 support rows | 0.26 | 0.24 | 20,168 | +| Candidate, 2048 support rows | 0.27 | 0.25 | 22,012 | + +These are single fixed first observations, including guarded startup, runtime/source checks and the declared finite consumer. They show no saving. The candidate's recorded wall, CPU and peak RSS are higher; the rounded single samples do not establish a repeatable regression magnitude. The tiny finite fixture is not a full H25 performance proxy. + +The bounded comparison and explicit no-gain disposition are accepted. F7 remains partial because complete physical cost closure is still open: preparation, independent validation/readback and final metadata/publication tails are unmeasured and are not zero. Charged policy usage is 75.750533479 seconds under the existing budget; that policy total includes nominal administrative charges and is not a measured physical total. Complete H25 caller/artifact qualification, full-workload performance and the original six-area goal percentages remain unchanged. diff --git a/research/h25-bounded-serializer/validation/reviews/RUNTIME-OUTCOME-REVIEW-v1.json b/research/h25-bounded-serializer/validation/reviews/RUNTIME-OUTCOME-REVIEW-v1.json new file mode 100644 index 0000000000..5125ae762e --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/RUNTIME-OUTCOME-REVIEW-v1.json @@ -0,0 +1,453 @@ +{ + "F5": "ACCEPT", + "F6": "ACCEPT", + "F7": "PARTIAL_BOUNDED_COMPARISON_ACCEPTED_COMPLETE_COST_CLOSURE_OPEN", + "F7_qualification_boundary": "Exact bounded fixture equality, measured command wall/CPU/peak evidence, all control costs and explicit no-gain disposition accepted. Fixed F7 remains incomplete for complete physical cost closure because preparation/independent validation/readback/final metadata-publication tails remain unmeasured and OPEN_NOT_ZERO; nominal administration is policy accounting, not measured physical cost. No full-workload saving or full caller claim.", + "candidate_operation": { + "batch_bytes_limit": 1048576, + "batch_count": 11, + "batch_rows_limit": 1024, + "cleanup": [ + "result.json", + "witness.json", + "rank-trace.json", + "stage_directory" + ], + "copy_bytes_limit": 1048576, + "files": { + "rank-trace.json": { + "accepted_write_bytes": 29, + "copy_read_bytes": 29, + "copy_sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "copy_write_bytes": 29, + "hashed_bytes": 29, + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe" + }, + "result.json": { + "accepted_write_bytes": 22, + "copy_read_bytes": 22, + "copy_sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "copy_write_bytes": 22, + "hashed_bytes": 22, + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2" + }, + "witness.json": { + "accepted_write_bytes": 9366, + "copy_read_bytes": 9366, + "copy_sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "copy_write_bytes": 9366, + "hashed_bytes": 9366, + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6" + } + }, + "largest_batch_bytes": 5121, + "phase": "complete", + "stage": "/home/d3lerium/.codex/.chatgpt-projects/g-p-6ad5817fd84881918865926b6fd51453/outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/component/.serialization-kfsp4n5e", + "status": "BOUNDED_SERIALIZATION_PASS" + }, + "controls": { + "serializer-controls-O": { + "bounded_success_operation_records": 13, + "controls_sha256": "ea43c633a1aade49791d56b33dedba70ed85dcaf42a8f58996ef9e215503ef3c", + "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." + ], + "disposition": "ACCEPT", + "independently_compared_original_candidate_case_pairs": 31, + "optimization": 1, + "ordered_cases": 70, + "retained_bytes": 132297, + "retained_failure_operation_records": 35 + }, + "serializer-controls-normal": { + "bounded_success_operation_records": 13, + "controls_sha256": "70d79f2c617a389d4b09729bcd42645bc1926784e70478245c75acba0aaf90b0", + "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." + ], + "disposition": "ACCEPT", + "independently_compared_original_candidate_case_pairs": 31, + "optimization": 0, + "ordered_cases": 70, + "retained_bytes": 132467, + "retained_failure_operation_records": 35 + } + }, + "corrected_four_operation_policy_seconds": "9.66", + "created_utc": "2026-10-31T04:51:22.749765+00:00", + "defects": [], + "evidence": { + "/etc/python3.12/sitecustomize.py": { + "bytes": 155, + "sha256": "43d81125d92376b1a69d53a71126a041cc9a18d8080e92dea0a2ae23be138b1e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/attempts/serializer-controls-normal.time.txt": { + "bytes": 119, + "sha256": "d5d32f91891738afa592aefbe405c68ba8dcec1fffad66d5cc25d1063e5962b9" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/START.json": { + "bytes": 1073, + "sha256": "5a5cb57fd9ef2e8a3d8b9827cfb7e666d872f4dd215a1475f95396189b86f89e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/receipt.json": { + "bytes": 2108, + "sha256": "c5908920fefde3b20a25290f0b38b5dbd9fcd237cd73a51ad23ec7c50531ba2d" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/science/adapter-boundary.json": { + "bytes": 689, + "sha256": "233809ac78d99a4a087c485e325c8d77545ee6a05a4cf5d05b1d80aefe634d18" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/stderr.txt": { + "bytes": 1635, + "sha256": "59a2dddcb39107e516cec72edcb661cf9e22c54d62be0676634b8e4049e28ddf" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/runtime/runs/serializer-controls-normal/stdout.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v1/stages/serializer-v1/integration/full_driver.py": { + "bytes": 8418, + "sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-baseline-2048.time.txt": { + "bytes": 81, + "sha256": "3f82a34b5950eaf2fb6af42a72503e23925efb30eadece7cf8b948c44ae905a5" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-candidate-2048.time.txt": { + "bytes": 81, + "sha256": "9b4271ac7ac4f1a46d823f925c8ae67f8bbd3782edee9d6c0ff428c5bcf90f63" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-O.time.txt": { + "bytes": 81, + "sha256": "af15e1b7b504c15e84ff4c7819a50cbc9e510d895f53a2e39959223eaf5fb1a8" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/attempts/serializer-controls-normal.time.txt": { + "bytes": 81, + "sha256": "d17b84ec4df4da64eefc34f2ef9a6685b4afd3ff301fa0c8720a83d9526a10f9" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-001.json": { + "bytes": 2954, + "sha256": "18d39ae470e131249a0380bf254d140739c6ddc41e29cd0d29f511bd88312448" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-002.json": { + "bytes": 2924, + "sha256": "9773784a0a02b08b4f3972fe0e954006d626700093a122ccebfc0ed5d89d3bd3" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-003.json": { + "bytes": 2923, + "sha256": "79cefa10887c393c80bb78b1038155013605252f81383648920d771bdbb9c500" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/control/LEDGER-004.json": { + "bytes": 2982, + "sha256": "8cf5f8b1a1e53436d02cd3be99ffd114f6582433db9b1f6ab19d8ae0ab6bc2e8" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/START.json": { + "bytes": 1087, + "sha256": "9e5d7e3c5a96596b9bf5b20468eca5cfc77d2b34a324c479969cc0f967e91d5d" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/receipt.json": { + "bytes": 2077, + "sha256": "39488c2da662e69919acabe2fa0593699baa9fcd248744137c584b0fbdae181d" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science/adapter-boundary.json": { + "bytes": 12157, + "sha256": "3285fe2ce9723396d6169138a4ecc2c304274856d4b4667ff24b6aa7f0e6eaf6" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science/component/component-receipt.json": { + "bytes": 1128, + "sha256": "b5d4276150930e7d428893af1d6017d8f3acbeb9408e4e9a4bc03e6dc21e82eb" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science/component/rank-trace.json": { + "bytes": 29, + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science/component/result.json": { + "bytes": 22, + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/science/component/witness.json": { + "bytes": 9366, + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/stderr.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-baseline-2048/stdout.txt": { + "bytes": 79, + "sha256": "0bdaf7b0ddda9a07cb13a5a10758487d32ef1abce088719f58880db70af4ebe0" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/START.json": { + "bytes": 1091, + "sha256": "3e446925b67a8768fad7c93c47d46ea8090982e62fd687cc20be6f6d0915eca3" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/receipt.json": { + "bytes": 2068, + "sha256": "e1ab7b9fba3f60b9ec2301bfc0d17fab99edceaab594d80aeb9da06ecbd917a9" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/adapter-boundary.json": { + "bytes": 12670, + "sha256": "27799c52c8a697648e2a8fbe2911e008e9fd863422b1c2c09b240e2491f4e840" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/component/component-receipt.json": { + "bytes": 2768, + "sha256": "06900868428688a7d0b8319a13fbe33c9f1348d2ba5bd0c3a2342c4eb3a17e3c" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/component/rank-trace.json": { + "bytes": 29, + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/component/result.json": { + "bytes": 22, + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/science/component/witness.json": { + "bytes": 9366, + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/stderr.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-candidate-2048/stdout.txt": { + "bytes": 80, + "sha256": "13841868bf237a386e69f64bbe8061eda663cde3594184e80fe6a874c737f11b" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/START.json": { + "bytes": 1083, + "sha256": "b385ef98b6ecf7616f7c608dda33b18717780a6c205cb20926fa259a088f784f" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/receipt.json": { + "bytes": 2059, + "sha256": "19d317593dfee82dd4cfc0b44be48cff1d12ef11d793be4e6b3f1db29a3f8ca1" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/adapter-boundary.json": { + "bytes": 12958, + "sha256": "5468c842f59a2c041a07f77ae495591753e70da71b1592b1371f38ea898afb4e" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/component-control-acceptance.json": { + "bytes": 167, + "sha256": "3a0e95fe2070e2be534f9e77280f792e845f47cbdd470adf6dc72fd7ede6925f" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/science/component/controls.json": { + "bytes": 88571, + "sha256": "ea43c633a1aade49791d56b33dedba70ed85dcaf42a8f58996ef9e215503ef3c" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/stderr.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-O/stdout.txt": { + "bytes": 79, + "sha256": "b1e5d8aacb1b6e269fae5a140a4fd53351d84161ee1c5fc0a82a26b8f78795b5" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/START.json": { + "bytes": 1073, + "sha256": "e40a06d1ada8d740bfed80629bf9d9d0f63626ddaa65a1d63b0d80aa41deba59" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/receipt.json": { + "bytes": 2048, + "sha256": "4ed9637fb3f45bcbeb85e17f3b3cd6597ebeb389083f9be99f163efa9453b503" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/adapter-boundary.json": { + "bytes": 12958, + "sha256": "68c9bfc3e0bd6726b8363e52d7abd780930502979c5f18ed694eda3d9b5184d2" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/component-control-acceptance.json": { + "bytes": 167, + "sha256": "fba682206a720d8c8c3a167c2d4e57d6b6875d7e82e846f33cf138019f56fd56" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/science/component/controls.json": { + "bytes": 88806, + "sha256": "70d79f2c617a389d4b09729bcd42645bc1926784e70478245c75acba0aaf90b0" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/stderr.txt": { + "bytes": 0, + "sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + }, + "outputs/h25-data-handling-20261028/streams/independent-components-20261031/execution-v2/runtime/runs/serializer-controls-normal/stdout.txt": { + "bytes": 79, + "sha256": "1a0ef58a650559d0f38dba77eb5c9dacaeaa4a39405e04a38f3e420367a5220b" + } + }, + "final_policy_seconds": "75.750533479", + "finite_artifacts": { + "rank-trace.json": { + "bytes": 29, + "sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe" + }, + "result.json": { + "bytes": 22, + "sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2" + }, + "witness.json": { + "bytes": 9366, + "sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6" + } + }, + "finite_bytes_total": 9417, + "finite_candidate_IO_bill": { + "common_finite_expected_canonical_hash_input_each_arm_bytes": 9417, + "consumer_readback_each_arm_bytes": 9417, + "copy_read_bytes": 9417, + "final_write_bytes": 9417, + "stage_plus_copy_hash_input_bytes": 18834, + "stage_write_bytes": 9417, + "this_independent_comparison_readback_both_arms_bytes": 18834, + "total_write_bytes": 18834 + }, + "finite_receipt": { + "exact_witness_sha256": "1bf09976a301dc9889ad00bd97528dbf238a27cac7c59d2fca93beccd5dc02a6", + "rank_call_count": 3, + "rank_distinct_matrix_count": 2, + "rank_trace_sha256": "1fdcfd74b078504a40ab3c10c7da80c987574fc4b99134845ee9aedd4dbb4ebe", + "result_sha256": "cef22173212b3944ad10917a693e816a0e44e356cf4d78bd9249ea830d0086e2", + "serialized_bytes": { + "rank_trace": 29, + "result": 22, + "witness": 9366 + } + }, + "first_failure_preserved": true, + "method": "Retained metadata/control JSON/raw finite artifact byte/hash comparison only; no target imports, tests, reruns, process inspection or scientific execution.", + "no_additional_target_execution": true, + "operations": { + "serializer-baseline-2048": { + "checks": { + "boundary_success": true, + "guardPASS": true, + "logs_raw_hashes": true, + "logs_stable": true, + "resource_caps": true, + "runtime_before_after": true, + "source_unchanged": true, + "stage_pin": true, + "stderr_empty": true + }, + "inner_command_wall_seconds": 0.2064995289547369, + "inner_runner_wall_seconds": 0.21762533904984593, + "inner_timed_child": { + "exit": 0, + "kernel_max_rss_kib": 20168, + "system_seconds": 0.03, + "user_seconds": 0.14 + }, + "outer_CPU_seconds": "0.24", + "outer_GNU": { + "exit": "0", + "max_rss_kib": "20168", + "system_seconds": "0.04", + "user_seconds": "0.20", + "wall_seconds": "0.26" + }, + "policy_charge_seconds": "2.27", + "policy_total_seconds": "73.470533479", + "sampled_group_peak_bytes": 22081536 + }, + "serializer-candidate-2048": { + "checks": { + "boundary_success": true, + "guardPASS": true, + "logs_raw_hashes": true, + "logs_stable": true, + "resource_caps": true, + "runtime_before_after": true, + "source_unchanged": true, + "stage_pin": true, + "stderr_empty": true + }, + "inner_command_wall_seconds": 0.2042087479494512, + "inner_runner_wall_seconds": 0.21725735603831708, + "inner_timed_child": { + "exit": 0, + "kernel_max_rss_kib": 22012, + "system_seconds": 0.02, + "user_seconds": 0.16 + }, + "outer_CPU_seconds": "0.25", + "outer_GNU": { + "exit": "0", + "max_rss_kib": "22012", + "system_seconds": "0.03", + "user_seconds": "0.22", + "wall_seconds": "0.27" + }, + "policy_charge_seconds": "2.28", + "policy_total_seconds": "75.750533479", + "sampled_group_peak_bytes": 23973888 + }, + "serializer-controls-O": { + "checks": { + "boundary_success": true, + "guardPASS": true, + "logs_raw_hashes": true, + "logs_stable": true, + "resource_caps": true, + "runtime_before_after": true, + "source_unchanged": true, + "stage_pin": true, + "stderr_empty": true + }, + "inner_command_wall_seconds": 0.5110593680292368, + "inner_runner_wall_seconds": 0.5206207169685513, + "inner_timed_child": { + "exit": 0, + "kernel_max_rss_kib": 23672, + "system_seconds": 0.06, + "user_seconds": 0.42 + }, + "outer_CPU_seconds": "0.55", + "outer_GNU": { + "exit": "0", + "max_rss_kib": "23672", + "system_seconds": "0.08", + "user_seconds": "0.47", + "wall_seconds": "0.56" + }, + "policy_charge_seconds": "2.57", + "policy_total_seconds": "71.200533479", + "sampled_group_peak_bytes": 25280512 + }, + "serializer-controls-normal": { + "checks": { + "boundary_success": true, + "guardPASS": true, + "logs_raw_hashes": true, + "logs_stable": true, + "resource_caps": true, + "runtime_before_after": true, + "source_unchanged": true, + "stage_pin": true, + "stderr_empty": true + }, + "inner_command_wall_seconds": 0.45877077197656035, + "inner_runner_wall_seconds": 0.4714004519628361, + "inner_timed_child": { + "exit": 0, + "kernel_max_rss_kib": 22592, + "system_seconds": 0.1, + "user_seconds": 0.3 + }, + "outer_CPU_seconds": "0.48", + "outer_GNU": { + "exit": "0", + "max_rss_kib": "22592", + "system_seconds": "0.12", + "user_seconds": "0.36", + "wall_seconds": "0.53" + }, + "policy_charge_seconds": "2.54", + "policy_total_seconds": "68.630533479", + "sampled_group_peak_bytes": 24567808 + } + }, + "original_six_area_goal_percentages": "UNCHANGED", + "performance_disposition": "NO_DEMONSTRATED_GAIN. Single fixed first sample per arm; outer GNU baseline .26s wall/.24s CPU/20168KiB peak vs candidate .27s wall/.25s CPU/22012KiB. Candidate raw observations higher by .01s wall,.01s CPU,1844KiB; rounded one-sample figures do not establish a repeatable regression magnitude. Tiny2048support-row/3rank-event fixture is not a fullH25 performance proxy. Inner child wall is a different narrower scope and is not a saving claim.", + "physical_boundary": "OPEN_NOT_ZERO", + "schema": "serializer-independent-runtime-outcome-review-v1", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/reviews/RUNTIME-REVIEW-FREEZE-v1.json b/research/h25-bounded-serializer/validation/reviews/RUNTIME-REVIEW-FREEZE-v1.json new file mode 100644 index 0000000000..f0ce5eacdf --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/RUNTIME-REVIEW-FREEZE-v1.json @@ -0,0 +1,22 @@ +{ + "F5": "ACCEPT", + "F6": "ACCEPT", + "F7": "PARTIAL_COMPLETE_PHYSICAL_COST_CLOSURE_OPEN", + "files": { + "PUBLIC-OUTCOME-v1.md": { + "bytes": 2343, + "mode": 292, + "sha256": "c46be8f94d046a4fd4e64b983b3a1d890be20d83a53329398f962922f08c67d8" + }, + "RUNTIME-OUTCOME-REVIEW-v1.json": { + "bytes": 23130, + "mode": 292, + "sha256": "d81065b5ba67f191b4f48705df393e12857919351eb6aa6857368777353428e6" + } + }, + "frozen_utc": "2026-10-31T04:52:05.320348+00:00", + "no_reviewer_target_execution": true, + "prior_failure_and_source_reviews_preserved": true, + "public_summary_scope": "Verbatim publication-ready source of independently checked bounded claims; original six-area percentages unchanged.", + "schema": "serializer-runtime-review-outcome-freeze-v1" +} diff --git a/research/h25-bounded-serializer/validation/reviews/RUNTIME-REVIEW-FREEZE-v2.json b/research/h25-bounded-serializer/validation/reviews/RUNTIME-REVIEW-FREEZE-v2.json new file mode 100644 index 0000000000..1d30eba410 --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/RUNTIME-REVIEW-FREEZE-v2.json @@ -0,0 +1,15 @@ +{ + "F5": "ACCEPT", + "F6": "ACCEPT", + "F7": "PARTIAL_COMPLETE_PHYSICAL_COST_CLOSURE_OPEN", + "change": "Readability spacing and correction from file pairs to case pairs; underlying measurements/dispositions unchanged.", + "frozen_utc": "2026-10-31T04:52:24.295934+00:00", + "governing_public_summary": { + "bytes": 2402, + "path": "outputs/h25-data-handling-20261028/streams/independent-components-20261031/review/PUBLIC-OUTCOME-v2.md", + "sha256": "57f92d6f42c714b4515c0044b3a1f2320537409857d5386e84186a27c01a2118" + }, + "predecessors_preserved": true, + "runtime_review_sha256": "d81065b5ba67f191b4f48705df393e12857919351eb6aa6857368777353428e6", + "schema": "serializer-public-outcome-additive-freeze-v2" +} diff --git a/research/h25-bounded-serializer/validation/reviews/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json b/research/h25-bounded-serializer/validation/reviews/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json new file mode 100644 index 0000000000..5947d7c299 --- /dev/null +++ b/research/h25-bounded-serializer/validation/reviews/SINGLE-REPAIR-EXACT-OPERATION-REVIEW-v1.json @@ -0,0 +1,64 @@ +{ + "added_file_pins": [ + "/etc/python3.12/sitecustomize.py" + ], + "added_module_origins": [ + "sitecustomize" + ], + "all_prior_runtime_file_and_module_pins_unchanged": true, + "changed_stage_files": [ + "RUNTIME-PINS.json", + "RUNTIME-PINS.sha256" + ], + "conditions": [ + "This consumes the single15minute source repair pass; no additional automatic source repair or same-stage retry.", + "Parent creates fresh exact one-use admissions; execute four declared operations serially in order, once each, with immediate charged reconciliation and independent evidence validation.", + "Any nonzero/timeout/unclosed/bad receipt/changed custody or independent rejection stops remainingdispatch; failed oldv1 admission remains cancelled.", + "Retain unchanged total2400/initial600 budget,180 original cap with tighter pinned117sINT+3sKILL wrapper, sampled1GiB and2MiB output guards,2+.01 nominal accounting and physicaltailunknown.", + "No runtime control success, performance gain, completeH25/host attestation or original-goal credit is granted by this source review." + ], + "created_utc": "2026-10-31T04:44:33.678129+00:00", + "current_charged_policy_seconds": "66.090533479", + "defects": [], + "disposition": "ACCEPT_PARENT_MAY_ADMIT", + "fresh_operations": [ + { + "fresh_all_evidence_paths": true, + "label": "serializer-controls-normal" + }, + { + "fresh_all_evidence_paths": true, + "label": "serializer-controls-O" + }, + { + "fresh_all_evidence_paths": true, + "label": "serializer-baseline-2048" + }, + { + "fresh_all_evidence_paths": true, + "label": "serializer-candidate-2048" + } + ], + "informational_findings": [ + "SOURCE-AUDIT adapter direct-import list omits pathlib, although actual unchanged adapter imports it. Existing runtime pins include pathlib; actual source and custody review cover it. This audit-list omission creates no runtime dependency gap.", + "Source audit honestly excludes lazy help/translation imports and apport work after finally on failing processes. Success/failure qualification remains based on actual retained boundaries; no full process-wide error-exit closure claim." + ], + "method": "Exact source/delta/argv review and ordinary source/runtime/launcher/failure metadata hashing only; no target execution, tests or process inspection.", + "operation_proposal_sha256": "2a707d3946343121a07150157c120f210afe84329bbe6a6c7b9d61d0719f71ea", + "prior_failure_evidence_preserved": true, + "prior_plus_four_reservations_seconds": "554.130533479", + "repair_deadline_utc": "2026-10-31T04:55:08.521435Z", + "repair_payload_files": 7, + "repair_source_manifest_sha256": "22b114fae2de5331e1c86bad5a2b61655184bdf06eb138a1c4e2fe0d7d46bf9b", + "reviewer_target_imports_or_executions": 0, + "runtime_files": 85, + "runtime_manifest_sha256": "972dd65db6a105dc3da4b29e12e924916930d5b691359dcc9c01eeda585b0e02", + "runtime_result_qualification": false, + "schema": "serializer-independent-single-repair-operation-review-v1", + "scope": "Single permitted source repair of concrete runtime origin omission, distinct exact immutable serializer-v2 stage and four fresh one-use commands only. Parent remains sole admission/execution owner.", + "stage_payload_files": 26, + "stage_sha256": "13be88a05b2bb376b0cfdedbb37bc97334cecabd4429fe9e7b348411f3c1ac04", + "unchanged_adapter_sha256": "515b5944415058777d6812e9ae59f4ef030c081803bfc76e1ea7830cd1bbc71a", + "unchanged_guard_sha256": "32633e40364d824c9f942af1ad2934da9701117328364c7c3f418b21b2e8054a", + "whole_H25_qualification": false +} diff --git a/research/h25-bounded-serializer/validation/run_guarded.py b/research/h25-bounded-serializer/validation/run_guarded.py new file mode 100644 index 0000000000..8111e2abd1 --- /dev/null +++ b/research/h25-bounded-serializer/validation/run_guarded.py @@ -0,0 +1,261 @@ +#!/usr/bin/env python3 +"""Parent-only serial immutable-stage runner with bounded retained-log reads.""" +import argparse +import fcntl +import hashlib +import json +import os +from pathlib import Path +import platform +import resource +import signal +import stat +import subprocess +import sys +import time + +HERE = Path(__file__).resolve().parent +TIMEOUT = 180 +RSS_CAP = 1024 ** 3 +OUTPUT_CAP = 2 * 1024 ** 2 +TOTAL_CAP = 2400 +LOG_CHUNK_BYTES = 64 * 1024 +USAGE_METADATA_CAP = 16 * 1024 + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def inventory(stage): + rows = {} + for path in sorted(stage.rglob('*')): + if path.is_symlink(): + raise ValueError('Symlink in immutable stage') + if path.is_file() and path.name != 'STAGE.json': + rows[str(path.relative_to(stage))] = { + 'sha256': digest(path.read_bytes()), + 'mode': path.stat().st_mode & 0o777, + } + return rows + + +def group_rss(group): + total = 0 + for path in Path('/proc').iterdir(): + if not path.name.isdigit(): + continue + try: + raw = (path / 'stat').read_text() + fields = raw[raw.rfind(')') + 2:].split() + if int(fields[2]) == group: + total += int(fields[21]) * os.sysconf('SC_PAGE_SIZE') + except (FileNotFoundError, ProcessLookupError, PermissionError): + pass + return total + + +def log_identity(value): + """Exclude atime: our own read may change it.""" + return (value.st_dev, value.st_ino, value.st_mode, value.st_size, + value.st_mtime_ns, value.st_ctime_ns) + + +def stream_log(path): + """Hash a finite snapshot in bounded memory, failing closed on file drift. + + A stable record covers every byte of the retained file. An unstable record + describes only the bytes actually hashed and cannot support a PASS. Reading + at most the initial length also prevents a growing file prolonging hashing. + """ + path_before = path.stat(follow_symlinks=False) + fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK) + with os.fdopen(fd, 'rb', buffering=0) as stream: + before = os.fstat(stream.fileno()) + if not stat.S_ISREG(before.st_mode): + raise ValueError('Retained log must be a regular file') + hasher = hashlib.sha256() + count = 0 + while count < before.st_size: + block = stream.read(min(LOG_CHUNK_BYTES, before.st_size - count)) + if not block: + break + hasher.update(block) + count += len(block) + after = os.fstat(stream.fileno()) + path_after = path.stat(follow_symlinks=False) + stable = (log_identity(path_before) == log_identity(before) == + log_identity(after) == log_identity(path_after) and + count == before.st_size) + return {'sha256': hasher.hexdigest(), 'bytes': count, + 'snapshot_bytes': before.st_size, 'final_bytes': path_after.st_size, + 'stable': stable} + + +def finalize_logs(folder, stop): + """Check sizes before any log read, stream complete stable evidence, recheck.""" + paths = [folder / 'stdout.txt', folder / 'stderr.txt'] + before = [path.stat(follow_symlinks=False) for path in paths] + cap_seen = 'process_monitor' if stop == 'output_cap' else None + if max(value.st_size for value in before) > OUTPUT_CAP: + stop = stop or 'output_cap' + cap_seen = cap_seen or 'before_stream_hash' + records = [stream_log(path) for path in paths] + final = [path.stat(follow_symlinks=False) for path in paths] + if max(value.st_size for value in final) > OUTPUT_CAP: + stop = stop or 'output_cap' + cap_seen = cap_seen or 'after_stream_hash' + for initial, record, ending in zip(before, records, final): + record['final_bytes'] = ending.st_size + record['stable'] = (record['stable'] and + log_identity(initial) == log_identity(ending) and + record['bytes'] == ending.st_size) + if not all(record['stable'] for record in records): + stop = stop or 'output_changed_during_hash' + return records[0], records[1], stop, cap_seen + + +def read_usage(path): + """The time tool's small diagnostic must not reintroduce an unbounded read.""" + if not path.exists(): + return None, False + size = path.stat().st_size + if size > USAGE_METADATA_CAP: + return {'raw_omitted': True, 'bytes': size}, True + with path.open('rb') as stream: + raw = stream.read(USAGE_METADATA_CAP + 1) + if len(raw) > USAGE_METADATA_CAP or path.stat().st_size > USAGE_METADATA_CAP: + return {'raw_omitted': True, 'bytes': path.stat().st_size}, True + try: + return json.loads(raw), False + except (json.JSONDecodeError, UnicodeDecodeError): + return {'raw': raw.decode('utf-8', errors='replace')}, False + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('stage') + parser.add_argument('job') + parser.add_argument('label') + args = parser.parse_args() + for value in (args.stage, args.job, args.label): + if not value or any(c not in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_' for c in value): + raise ValueError('Simple immutable stage/job/run names required') + runner_start = time.monotonic() + runner_usage_start = resource.getrusage(resource.RUSAGE_SELF) + (HERE / 'runtime').mkdir(exist_ok=True) + # A single parent owns this round; never wait behind another scientific run. + with (HERE / 'runtime/science.lock').open('a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + stage = HERE / 'stages' / args.stage + stage_raw = (stage / 'STAGE.json').read_bytes() + declared = json.loads(stage_raw) + before = inventory(stage) + if before != declared['files']: + raise ValueError('Stage bytes/modes differ from declared closure') + jobs = json.loads((stage / 'JOBS.json').read_bytes()) + job = jobs[args.job] + phase_raw = (HERE / 'control/EXECUTION-PHASE.json').read_bytes() + phase = json.loads(phase_raw) + cap = phase['aggregate_cap_seconds'] + if type(cap) is not int or cap not in (600, TOTAL_CAP): + raise ValueError('Unrecognized parent budget phase') + runs = HERE / 'runtime/runs' + runs.mkdir(exist_ok=True) + spent = 0.0 + for run in runs.iterdir(): + if not run.is_dir(): + continue + receipt_path = run / 'receipt.json' + if not receipt_path.exists(): + raise ValueError('Unclosed prior attempt: preserve and reconcile before another run') + prior = json.loads(receipt_path.read_bytes()) + spent += prior.get('runner_wall_seconds', prior['wall_seconds']) + if spent >= cap: + raise ValueError('Aggregate budget consumed') + folder = runs / args.label + folder.mkdir() + runner_before = Path(__file__).read_bytes() + if digest(runner_before) != declared['runner_sha256']: + raise ValueError('Actual runner differs from frozen runner source') + fraction_path = Path('/usr/lib/python3.12/fractions.py') + fractions_before = fraction_path.read_bytes() + env = os.environ.copy() + for name in ('PYTHONPATH', 'PYTHONOPTIMIZE', 'PYTHONINSPECT', 'PYTHONSTARTUP', 'PYTHONPYCACHEPREFIX'): + env.pop(name, None) + env.update(PYTHONHASHSEED='0', LC_ALL='C.UTF-8', TZ='UTC', PYTHONDONTWRITEBYTECODE='1') + command = ['/usr/bin/python3.12', '-B'] + if job.get('optimized', False): + command.append('-O') + command.extend([str(stage / 'integration/full_driver.py'), + '--output', str(folder / 'science'), + '--lanes', job['lanes']]) + if job.get('finite_only', False): + command.append('--finite-only') + usage = folder / 'usage.json' + timed = ['/usr/bin/time', '-f', '{"user_seconds":%U,"system_seconds":%S,"kernel_max_rss_kib":%M,"exit":%x}', '-o', str(usage), '--', *command] + started = {'command': command, 'stage_sha256': digest(stage_raw), + 'runner_sha256': digest(runner_before), 'fractions_sha256': digest(fractions_before), + 'budget_phase_sha256': digest(phase_raw), 'spent_before_seconds': spent, + 'phase_cap_seconds': cap, 'job': args.job, 'label': args.label} + (folder / 'START.json').write_text(json.dumps(started, indent=2, sort_keys=True) + '\n') + start = time.monotonic() + stop = None + peak = 0 + with (folder / 'stdout.txt').open('wb') as out, (folder / 'stderr.txt').open('wb') as err: + process = subprocess.Popen(timed, cwd=stage, env=env, stdout=out, stderr=err, start_new_session=True) + try: + while process.poll() is None: + peak = max(peak, group_rss(process.pid)) + if peak > RSS_CAP: + stop = 'sampled_group_rss_cap' + elif time.monotonic() - runner_start > min(TIMEOUT, cap - spent): + stop = 'wall_or_aggregate_cap' + elif max((folder / 'stdout.txt').stat().st_size, (folder / 'stderr.txt').stat().st_size) > OUTPUT_CAP: + stop = 'output_cap' + if stop: + os.killpg(process.pid, signal.SIGKILL) + break + time.sleep(0.05) + code = process.wait() + finally: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + elapsed = time.monotonic() - start + stdout, stderr, stop, cap_seen = finalize_logs(folder, stop) + measurement, oversized_usage = read_usage(usage) + if oversized_usage: + stop = stop or 'usage_metadata_cap' + unchanged = (inventory(stage) == before and (stage / 'STAGE.json').read_bytes() == stage_raw and + Path(__file__).read_bytes() == runner_before and fraction_path.read_bytes() == fractions_before) + runner_elapsed = time.monotonic() - runner_start + runner_usage_end = resource.getrusage(resource.RUSAGE_SELF) + if runner_elapsed > min(TIMEOUT, cap - spent): + stop = stop or 'wall_or_aggregate_cap' + if runner_usage_end.ru_maxrss * 1024 > RSS_CAP: + stop = stop or 'runner_rss_cap' + receipt = dict(started, exit=code, wall_seconds=elapsed, usage=measurement, + termination=stop, sampled_process_group_rss_bytes=peak, + source_bytes_and_modes_unchanged=unchanged, + stdout_sha256=stdout['sha256'], stdout_bytes=stdout['bytes'], + stderr_sha256=stderr['sha256'], stderr_bytes=stderr['bytes'], + stdout_final_bytes=stdout['final_bytes'], stderr_final_bytes=stderr['final_bytes'], + retained_log_bytes_stable=stdout['stable'] and stderr['stable'], + output_cap_observed_at=cap_seen, log_read_chunk_bytes=LOG_CHUNK_BYTES, + runner_wall_seconds=runner_elapsed, + runner_user_seconds=runner_usage_end.ru_utime - runner_usage_start.ru_utime, + runner_system_seconds=runner_usage_end.ru_stime - runner_usage_start.ru_stime, + runner_lifetime_max_rss_kib=runner_usage_end.ru_maxrss, + python=sys.version, platform=platform.platform(), + status='PASS' if code == 0 and stop is None and stderr['bytes'] == 0 and unchanged else 'STOP') + (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2, sort_keys=True) + '\n') + print(json.dumps(receipt, sort_keys=True), flush=True) + if receipt['status'] != 'PASS': + raise SystemExit(1) + + +if __name__ == '__main__': + main()