tlog: miroir Phoenix (tuiles C2SP) taille 15192

.gitattributes

@@ -58,3 +58,63 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/000 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/001 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/002 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/003 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/004 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/005 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/006 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/007 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/008 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/009 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/010 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/011 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/012 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/013 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/014 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/015 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/016 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/017 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/018 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/019 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/020 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/021 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/022 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/023 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/024 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/025 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/026 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/027 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/028 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/029 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/030 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/031 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/032 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/033 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/034 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/035 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/036 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/037 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/038 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/039 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/040 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/041 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/042 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/043 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/044 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/045 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/046 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/047 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/048 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/049 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/050 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/051 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/052 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/053 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/054 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/055 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/056 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/057 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/058 filter=lfs diff=lfs merge=lfs -text
+tlog/tile/entries-u32/059.p/88 filter=lfs diff=lfs merge=lfs -text

tlog/anchors/14513/head.canon.json

@@ -0,0 +1 @@
+{"canonicalization":"RFC 8785 (JCS)","hash":"SHA-256 RFC 6962 (feuille 0x00, noeud 0x01)","issuer_pin_sha256":"a7c6a35b1c2c81d589a30c2ad628679bdea9da4139d49aa3c42cdde6e1c65036","root_sha256":"0ab4827f75326fc23cc5db5c397c5a924a2ab7da636289ecfba379167ee18e3a","schema":"legion-mcp-tlog-sth/0.1","timestamp":"2026-10-09T03:55:39Z","tree_size":14513}

tlog/anchors/14513/ots_status.json

@@ -0,0 +1,16 @@
+{
+ "status": "pending",
+ "label": "ancrage pending",
+ "state": "complete_proof_file",
+ "checked_at": "2026-10-10T03:41:06Z",
+ "ots_verify": "not_run_no_bitcoin_node",
+ "ots_verify_output": "Could not connect to Bitcoin node: Cookie file unusable ([Errno 2] No such file or directory: '/home/legion33/.bitcoin/.cookie') and rpcpassword not specified in the configuration file: '/home/legion33/.bitcoin/bitcoin.conf'",
+ "explorers_crosscheck": {
+  "agree": true,
+  "check_ots": "verified",
+  "note": "indicatif seulement, ne scelle pas"
+ },
+ "verify_command": "ots upgrade head.canon.json.ots && ots verify -f head.canon.json head.canon.json.ots   # nécessite un nœud Bitcoin Core",
+ "bitcoin_attested_block": 970581,
+ "attested_block_time": "2026-10-09T04:23:19Z"
+}

tlog/anchors/15192/head.canon.json

@@ -0,0 +1 @@
+{"canonicalization":"RFC 8785 (JCS)","hash":"SHA-256 RFC 6962 (feuille 0x00, noeud 0x01)","issuer_pin_sha256":"cf9d6db5abbcc13e3a2ae2c25cece35b77f3a330aacfa7194bbfa8a03d2935fd","root_sha256":"bf1e1b800d0424b103a7ee56221523ee777e5d85e614e0baabce92b5f0402a6f","schema":"legion-mcp-tlog-sth/0.1","timestamp":"2026-10-09T09:09:10Z","tree_size":15192}

tlog/anchors/15192/ots_status.json

@@ -0,0 +1,16 @@
+{
+ "status": "pending",
+ "label": "ancrage pending",
+ "state": "complete_proof_file",
+ "checked_at": "2026-10-10T03:41:13Z",
+ "ots_verify": "not_run_no_bitcoin_node",
+ "ots_verify_output": "Could not connect to Bitcoin node: Cookie file unusable ([Errno 2] No such file or directory: '/home/legion33/.bitcoin/.cookie') and rpcpassword not specified in the configuration file: '/home/legion33/.bitcoin/bitcoin.conf'",
+ "explorers_crosscheck": {
+  "agree": true,
+  "check_ots": "verified",
+  "note": "indicatif seulement, ne scelle pas"
+ },
+ "verify_command": "ots upgrade head.canon.json.ots && ots verify -f head.canon.json head.canon.json.ots   # nécessite un nœud Bitcoin Core",
+ "bitcoin_attested_block": 970607,
+ "attested_block_time": "2026-10-09T09:11:36Z"
+}

tlog/checkpoint

@@ -0,0 +1,5 @@
+tlog.legion-api.com/mcp/v0
+15192
+vx4bgA0EJLEDp+5WIhUj7nd+XYXmFOC6q86StfBAKm8=
+
+— legion-mcp-tlog z8CYj1VZrNkgGdJS/nNpkLfpXmDfcJD3EpUo+SZ20V4kHX8GboZ7cewUBtjpAZckVeRPhUrGzF3rPqTz/Ld/b/M9SAk=

tlog/heads.jsonl

@@ -0,0 +1,2 @@
+{"signature_ed25519": "XFSR3CxRvjoIaLLXoxjNf5rqJpB7MS8Hyf2/LOJCfbiLrz+DBj3Ch0/mprTGfr+wGmhE209WABf9Hwkf/G3GBw==", "tree_head": {"canonicalization": "RFC 8785 (JCS)", "hash": "SHA-256 RFC 6962 (feuille 0x00, noeud 0x01)", "issuer_pin_sha256": "a7c6a35b1c2c81d589a30c2ad628679bdea9da4139d49aa3c42cdde6e1c65036", "root_sha256": "0ab4827f75326fc23cc5db5c397c5a924a2ab7da636289ecfba379167ee18e3a", "schema": "legion-mcp-tlog-sth/0.1", "timestamp": "2026-10-09T03:55:39Z", "tree_size": 14513}}
+{"signature_ed25519": "HPF5EPdI1XkSwnEq8AhyYAMio4QtktKPHqGf0uacXHwVpyN+B+X3Wsw/1jpQh5I3smnv0Vbj2GY4uuom5HhTCA==", "tree_head": {"canonicalization": "RFC 8785 (JCS)", "hash": "SHA-256 RFC 6962 (feuille 0x00, noeud 0x01)", "issuer_pin_sha256": "cf9d6db5abbcc13e3a2ae2c25cece35b77f3a330aacfa7194bbfa8a03d2935fd", "root_sha256": "bf1e1b800d0424b103a7ee56221523ee777e5d85e614e0baabce92b5f0402a6f", "schema": "legion-mcp-tlog-sth/0.1", "timestamp": "2026-10-09T09:09:10Z", "tree_size": 15192}}

tlog/keyring.jsonl

@@ -0,0 +1,4 @@
+{"type": "key_register", "key_id": "k1:a7c6a35b1c2c81d589a30c2ad628679b", "alg": "Ed25519", "public_key_b64": "ENTr9tUMHipzZIBmrau7pH7+Py6szwCaj/9HKRZp4P8=", "issuer_claimed": "LEGION (legion-api.com)", "valid_from": "2026-09-25T23:31:14+00:00", "self_sig": "hAYdJX83NXif3trV0n2qqJiycpc/5V3MFh7ymLdvhUHLkuDdk31bvJQvURn2tlGjZ1rcSYIWStgC9215MgJpBA==", "prev_hash": "0000000000000000000000000000000000000000000000000000000000000000", "hash": "b7c96655e8f9f7e908647fa0d5fb42d3fef6530b81bb7964096e4620e181ce3e"}
+{"alg": "Ed25519", "endorsed_by": "k1:a7c6a35b1c2c81d589a30c2ad628679b", "endorsement_sig": "m9JTd/UuPR90DDHry217jhzUuK3fctXY+4RWe3+ICkT99GHAQqU5NCvRdutPPEwPfr4tqtkhnAvkfY2bzFXXAg==", "hash": "70016e8f298daf4045de6939ffa39db2a48ac9aa611570b89b7cb1e046937c95", "key_id": "k1:cf9d6db5abbcc13e3a2ae2c25cece35b", "note": "sous-clé dédiée au journal de transparence MCP ; révocable par key_revoke signé par la racine, sans effet sur Phoenix ni les passeports", "prev_hash": "b7c96655e8f9f7e908647fa0d5fb42d3fef6530b81bb7964096e4620e181ce3e", "public_key_b64": "8TjBgwUacWWGT843hCd/3xc2I5NQk0ljfLTwMC/2HGQ=", "purpose": "mcp-tlog", "self_sig": "uiQA4+0IfupO0oUs7yhlUDNxfdEhss001vmJnejVio3itVADypikO4d8JpiSzGzF5l33IW6F+erR4JKTHv0WAw==", "type": "key_register", "valid_from": "2026-10-09T07:49:26Z"}
+{"alg": "Ed25519", "endorsed_by": "k1:a7c6a35b1c2c81d589a30c2ad628679b", "endorsement_sig": "Bx3veoPJHaaHYkTmBlLlDy2my2pQkuD3n5bGHDc/jtMyRYMoGsNs/SQtUaxQGb8+XZVN4X4kjIr2IYrFg50FDA==", "hash": "d09d87e8f5841f99d4408ee1436f880b35f18a0f77b39f5813dc05143a42a88d", "key_id": "k1:70bebb9689bb3d5c4a270d3d379d8d6a", "note": "sous-clé dédiée au tape des politiques (A1) ; révocable par key_revoke de la racine sans effet sur le journal MCP", "prev_hash": "70016e8f298daf4045de6939ffa39db2a48ac9aa611570b89b7cb1e046937c95", "public_key_b64": "BdlQXuLIhN/Vodkh3g1JM2BqgKmvkW+BhebRtJOqBvA=", "purpose": "policy-tape", "self_sig": "6emiZ96BEnFFCaVkE3ODgXR8ICQCpytFxzx41t4MDjAq0LdXZHAVJcz+w1pgre+2ItXQPo8B80/yCwao4kj8CQ==", "type": "key_register", "valid_from": "2026-10-09T10:46:55Z"}
+{"alg": "Ed25519", "endorsed_by": "k1:a7c6a35b1c2c81d589a30c2ad628679b", "endorsement_sig": "RTVxDre7hBoSzqffff48eIhT3jGcXfRHxHeRis2sl81CT4nk00tptwR9LTBEe6jTG4ncGb/i4yW4SrrWLq6iAw==", "hash": "cc0b5dc2ef1541cceae1ae9cb6028ea532a9daeaba0a440f4b8a8e6a3e4357ec", "key_id": "k1:ae5eca436cb32ef21275437ad750238b", "note": "sous-clé dédiée au tape de statut (A3)", "prev_hash": "d09d87e8f5841f99d4408ee1436f880b35f18a0f77b39f5813dc05143a42a88d", "public_key_b64": "P+75m2Bg75gguMjqGybN+5p6C9Pw5L/fosaj0UfVx6E=", "purpose": "status-tape", "self_sig": "7mM5DcgrLCk8VrhzQObkust2W8XizVnmO02qTLb91B4Eh0p0+vVEDjTTFlOjNdgbsoN4YqN9MFIFEpqvVWxsAw==", "type": "key_register", "valid_from": "2026-10-09T11:48:38Z"}

tlog/phoenix.json

@@ -0,0 +1,151 @@
+{
+ "anchors": [
+  14513,
+  15192
+ ],
+ "exported_at": "2026-10-10T04:22:56Z",
+ "files_sha256": {
+  "anchors/14513/head.canon.json": "a2551bbebe13cb1f59aa8b1926b1e7c3b4cb1b82e810586c64d96491bad0125f",
+  "anchors/14513/head.canon.json.ots": "160d6f14fe5f209960943db5d173ba21f863a9bf5f0738ecd6bc62b204c90f96",
+  "anchors/14513/ots_status.json": "de68408e96ff72eadf561cc3e3e973bf7c6ac600c77803ba4b4b07fee62b6e20",
+  "anchors/15192/head.canon.json": "d25443d0bcc2a1f36a766d9ac8fe2f664e2dd34599f46207fd283a6d248f37d0",
+  "anchors/15192/head.canon.json.ots": "942527a4fc2375ed2cc61e1a419f9a8120ed729f05e205460d780f8eb18fc823",
+  "anchors/15192/ots_status.json": "2db234d4a5f79ae15c9f9099358f35404adb5771785ed46185a7d5c6571284c7",
+  "checkpoint": "9a80188f53fdeb753beeb842fd8a1c53f1fb3a85e9d61df6975be965432c5741",
+  "heads.jsonl": "d0b08c027b4f06bafe34a8890dccbf55286fa5a2fc4a7bc8ea527d35adce85a6",
+  "keyring.jsonl": "14ca2c75193e79050d1697e04ba765b8158c1fab81cc0b24123df6b4cd584ade",
+  "resurrect.py": "02ad3853c87eff748204ac69157a2dda75155489a36ed44216704204c54cf32d",
+  "tile/0/000": "dffa877e584620f4ab92dfbf149e699c524090bc688ef5555d03196bb8425930",
+  "tile/0/001": "e84570e8c34beaf9efe124aec5628dc724c6ae6b26e1807c9bdf4298b315307c",
+  "tile/0/002": "f626a1e1b47f4df812c704af9a9fcd7a4fda22d5aee5202cda3c254a33aabe74",
+  "tile/0/003": "813bd6ffd626b49348cef2eb192139a2ee8d0a927b4ba59ca812e05527338322",
+  "tile/0/004": "b5c1f2cf9148ba1eab413ea84c7f2121981e3a4120569953363cfaf0c35ff351",
+  "tile/0/005": "a24dc8ddb01b9078a055541cbdc503b924e35f6857d5cf89ded286b8df2eab34",
+  "tile/0/006": "10a193c47859467e5c723b2de593baae75e440a13ba2c4ad4873ce19655fa2d3",
+  "tile/0/007": "0caa4604b227916b88e4ed6292ef957de6fcbbe03c6213602d70f091aae0fce7",
+  "tile/0/008": "5c85112502270ff7f0b7399eb33e65ecf0315a84ba75b5062b728de9d4b53d72",
+  "tile/0/009": "40e797eb1f4fa68ca6cc2b1e2895a158bdc32bcfee18022984a70fe0ad0bba96",
+  "tile/0/010": "6a3e6290fe64cec47a27c2f336dd985c51b301f142b9cde3e9a77ebd5a5165aa",
+  "tile/0/011": "0bb619a32f4dd7c6ff4c043057f895a07efd884e9ab29b31736bae0ff5a196cd",
+  "tile/0/012": "252693cd489b53cb323564788b8651e244cf98056d560b39329129e1db12315e",
+  "tile/0/013": "c16a27b441aab047d7f9a7a4e8722b8a58a380d4afee7016d11f1caae47cf68b",
+  "tile/0/014": "8ce929e860f8e78cd54a685e4065fa0c4c8482a752855d34a3dffaf6f6f9e556",
+  "tile/0/015": "7811e4fcc40964e83ec24ff83307421236e120a1c10589c90d5c8d29e95a791a",
+  "tile/0/016": "999c534e2480f9483318666c87800c8e1045579a9bdc49725d8707b0236ffda7",
+  "tile/0/017": "08397dc360fe4dfa0af4961c11c85e2f19bd2bdbdf23851634bd3eb507aa0bf4",
+  "tile/0/018": "3492b52cdc3d6cd9ad3f91fb14a567a32c8eca8378e767e4bf6838fb7767c612",
+  "tile/0/019": "17cd59c28827d2d89e2d3a7e492968f5f38193f0005dd45fbb59dca5d333f324",
+  "tile/0/020": "136366884b65351581452e273655f2ddea97673b8c8c768e46800cc160dc3478",
+  "tile/0/021": "aa932d3fd385096a21fd2ed04a96075492329446ed4296ad7d91363454d6da4f",
+  "tile/0/022": "824640e60f3625de167bfb34766a6def4a03753f5ed3d1c1d0646143c797e928",
+  "tile/0/023": "b97e73f491a355bf4cdd8d02652650c28b4e58147b4061fc4a2f205d0b4847db",
+  "tile/0/024": "8fec03f4924682512738e77e33dc57878db1e8950c702ff753e28d9e15190216",
+  "tile/0/025": "594cf51afa956b58d39f0b16f7e7fc92a8a7e06ed586f893a5b1ec62ca8a3da4",
+  "tile/0/026": "e848d289f75e73e57d5165367ef5a7cf1d41211089a2aea8440098c3aae2bddd",
+  "tile/0/027": "330871489b9c75e51cbb31f3fb3cfff2a1e5aed3410b278c90c17e44ef0332a7",
+  "tile/0/028": "cee7120cfd733fccfd157f20192ba34d1e9dfe26263238f81cfc212f2ad439f5",
+  "tile/0/029": "2067746159699a20b6d3932958c2df5df31bac75fe7ac76663d029135ead40f5",
+  "tile/0/030": "4494035855c798bc16ea038266a5b7d65a2f1d92883babecde6aeceb15834f82",
+  "tile/0/031": "b8a00681524d94e11a52e6f973546e0dbc05cb833f8a822e1fbe1452be2927a5",
+  "tile/0/032": "758e3949ba14c3128b21824302a3e4e4ff1c470f92a71d0bb15d8b6155ab27a9",
+  "tile/0/033": "83ab270c2739cec10f37924b99ff9e12e507ca22ba59b92414cc4d01025143d2",
+  "tile/0/034": "6d11bf01d08041f5d79001cecf83ce836b9c1aeb80de74b05deb18dfd4fcbe9d",
+  "tile/0/035": "d3630425bbe63d35486af64ebc0f8f3f2928c5d9f4e6bf7d159ce1e042ed1585",
+  "tile/0/036": "90137a0b3a7f7edc000437792b47c6ce7102b3b7f0812c2850b53d7f30325f80",
+  "tile/0/037": "932b09e4f032c06859f17edea005a2311a46ae58f89123f3a0b398e04ce7e19c",
+  "tile/0/038": "650abb68042b48648676a7f8bd73dfd22705beb5e2fb406d82d6a5ed9e0b7780",
+  "tile/0/039": "c6beb68561c5e90aebd1030304a8bd55cc1415f236ed5398511d001299222100",
+  "tile/0/040": "fd0b43eef768e9edc99d85671286b975f7e79e63c140a1e791728af8e005fc27",
+  "tile/0/041": "5f51593a8a9e56933b6ff4e6369bf42c9be3fbd1e78bbfc8039454757ce1d855",
+  "tile/0/042": "cfb0353a1854b1dc5dedcca3752601e890e6df3f7f00ffefc47a056eb77b803f",
+  "tile/0/043": "cf44b68d8e41bd20390b1a0aaea281f8e3484c267909e0cb7133daf59492e7f6",
+  "tile/0/044": "b76f2b9ba90aeb65912086a124eec242e10e4274693f6b854b6b0f0cca2c79ee",
+  "tile/0/045": "33d98632a609b3648fa3f6f37fc1ca741ec27c89c9084a2fddde8080759ef987",
+  "tile/0/046": "d1167d91d094d0f139367effad9244c0270e4c269f9d3a81dbfb9f969daa5480",
+  "tile/0/047": "ce26900da1f60284dd869eec04e45136cc0c6d6fb3572ef34edd2fbb441e5fbc",
+  "tile/0/048": "3088bf69e024bd811388aaecc84c20fab81a034e2c45ce3f378cf9efe5eec75c",
+  "tile/0/049": "d6509a432d88d93f893a910a274539f0a3726f9f2ea2b2770f118e6b32c3c371",
+  "tile/0/050": "21a0f21ec8492bff7793cb1c89329c2b3dac5d08e34c1a6cf184d328824653b0",
+  "tile/0/051": "a653a1cad6a7a1f010bd7cfdb01d685116337de7258ce4265a4b1bcd71fe3971",
+  "tile/0/052": "1dcdd40eee9f2f8d8a7c8e1f3f14fb92c129a56aef78845c288e51a2ea39625c",
+  "tile/0/053": "385ccf1b37790ece2de03a2fa1aadcf13c5ec32e301516c172f6e46c89b2b29f",
+  "tile/0/054": "73ece2548bf332e8c4f57cfd807abaad98c3cf78b7c7e4c4152b722d51da9e07",
+  "tile/0/055": "f210861cdffff63d3c3eb6a47fa2bf5903641256d4ab43b476c234a9d21b76c1",
+  "tile/0/056": "f63d2160561a718b9babca3e1e825e63abdc83c93bf642eabf916b9b5979f59b",
+  "tile/0/057": "64c40eef891f3c63c95a9b0b52be5dafcc6c067a22b96ece4e2f58286f6fa587",
+  "tile/0/058": "c380f026f8ae7ff4765dc6516d509999d2ad3d9e9f92d3ef564058158b20aa37",
+  "tile/0/059.p/88": "c12cd986d4f1743093c234bdd137b1920514a09e8e8750908a818fa8ef7161b2",
+  "tile/1/000.p/59": "bb3ab44c014dadc78a78ece00ba73a57393901a2583254bbfb7d0fe905a4d700",
+  "tile/entries-u32/000": "876b4ba921cc8fef44fbf04965a8a541933b6baf95fb946a2998de4452249fb3",
+  "tile/entries-u32/001": "bc67b5be8d4081d52dff9187a3a772ceb080288a5c30da39f28bc74b05119232",
+  "tile/entries-u32/002": "3bc5d3c712615e8e475cf1d556b433509fa67121d6363c4cb266d88fd0ae06fb",
+  "tile/entries-u32/003": "603ad51cddc94f5733bef5221d2bf3fb2b61b813caeaea24705dc08e8a336ee4",
+  "tile/entries-u32/004": "263be8a93263a4167d3ff416ada3f2b62bed57b1534ca831ecbb2b83db71465b",
+  "tile/entries-u32/005": "85f5e5577483fb83e47c99ad279cb0c6e30153dfe2bba531a70ef9b55d6aad45",
+  "tile/entries-u32/006": "6f1fa6834146a87cee0f4bfee357b275e9d339c07b2fad94203fbb1e903b554e",
+  "tile/entries-u32/007": "57b72c94bcbffcb483bc92cc1e3547746a1d95d63e7094ed0f566be2ab71d19d",
+  "tile/entries-u32/008": "ed348a15b760302e73adacbc7a719a5fe77a5488f4dafd66feccbde302e7ae45",
+  "tile/entries-u32/009": "10719ccaef65933b5d2f9e39ca9efd24cb21c68db8ac08b899ccfd4de28c980c",
+  "tile/entries-u32/010": "68da731e8136793cd21f5b6cc28291c0b3ed3cc59769bf1d08f8772e076ab054",
+  "tile/entries-u32/011": "e5ac34a4d2ca7d5ddeef95a8c3b353241866b9763ceff28b34d5989e1abac9d9",
+  "tile/entries-u32/012": "64853fd12b5b247b3d9e012d32e76c46a173f33c741da59b5e4e7ccfb9d0214a",
+  "tile/entries-u32/013": "d2cd3ec045b9ebaee346e53029641d1915219ff73aa5c294e2be1f1c5bbd3208",
+  "tile/entries-u32/014": "3c3f15f21df50d713353efb66575ab6ef2ad4d466e1ce584479ff412a61c4f5e",
+  "tile/entries-u32/015": "7388343e6dc64f89d228dfac801f9fd83a6d8fdceba709c2ef45e4019d1ff620",
+  "tile/entries-u32/016": "f2818058abc34ee95eca4d5efc6d23c65f03ecfd6dad670bd01add93637ebadf",
+  "tile/entries-u32/017": "f2dca187f338a201076a0c0c6ad6d0ac29a7380e924aab36c855f099b76e2c11",
+  "tile/entries-u32/018": "fe952bc7a62ac9ab3c1d5625e5afa5415da6d08c0f85d47b4f9040a406689fe6",
+  "tile/entries-u32/019": "2c0b4d3ae9c153071482d5a345676d13123d9a8ca12cfe7133c18dc219ea0889",
+  "tile/entries-u32/020": "6f454e4dd729893232198313580f85776a8fe60a39487a7ddcd4c7cc77459941",
+  "tile/entries-u32/021": "beca1888a1b3467f2dc4e8134209ab08047bdc5938f627d7757a474980dc50c1",
+  "tile/entries-u32/022": "95af97e933f0e1b6742ebb60abcafab622265349a53579aa67d0f2d40b7a4fa1",
+  "tile/entries-u32/023": "6bef7253a53ef9586318dc351290369a5d356b7f1fe0c83ea4aa2b90dd0ccfe1",
+  "tile/entries-u32/024": "222b8d00ff32114b025d266be87dee1bcd4029270834e3a792b47aad43c1333b",
+  "tile/entries-u32/025": "e775066eba88bb38b2890236e1ba75500c8111acdf9b865f650d0d359e70fdc9",
+  "tile/entries-u32/026": "2095ee104de41a724f693d4cbe7ab35d6804b37b5574201f47bbfd3194e0d6c3",
+  "tile/entries-u32/027": "4071e948755c5b62c28616fbd0008b1ce46c063062a09756f6b7498b2a41a4a1",
+  "tile/entries-u32/028": "60ba8f0e7e9c3b5aaa817c8f08aebc05e3d767cc9d70ffab57c4043879f9ea00",
+  "tile/entries-u32/029": "77e530a36d9511760568a18ddfa7aee22d7342c46fe9e35afd88a3383a336a20",
+  "tile/entries-u32/030": "7a7066567e4b3fd247cec61c32302ab227bf2230fa053b9d8e1eb304b97a07b1",
+  "tile/entries-u32/031": "cf261bc75b367329b2d4569c816a659c84e9da554d0fe9538ab4f7b2de15fd53",
+  "tile/entries-u32/032": "84b787d43c9ef9574811050424885de067cf705f91ed6e78071de451f34fface",
+  "tile/entries-u32/033": "558e3208a6d841882d940f11b9ca55ee1e73d7592fe9547fbcbc7ea5883ba5c8",
+  "tile/entries-u32/034": "2cf0077627300e6ee555afa8b9308b8d9826a9a5edc857392e2bf3e05dfe68e8",
+  "tile/entries-u32/035": "5a3ac594c5aac00b23478ce0aa4908ef85a8fb1d371a7d2528d9fda5f5bcc64f",
+  "tile/entries-u32/036": "8897a244899b4f6d0a1e7a968d2ed449ba850fb59b61f4e40ef2b6f57d88ef92",
+  "tile/entries-u32/037": "307084029bc9a221936e2cb4bf9a0fc20dd27d9c3177b8c005ceae321325034c",
+  "tile/entries-u32/038": "e1592a037c7ce1221a857a04ed67917c14fcfd88b8264e6370819c776a392a55",
+  "tile/entries-u32/039": "705b85263dfc210799aca19f3c557c169be76ce2596db220bea4daab0162cd00",
+  "tile/entries-u32/040": "5ba62f2599f11677ed3ae36c9655ed380fae79a19abb447996448b380842fc7c",
+  "tile/entries-u32/041": "9f01ee62c8ae237f61997589a76d0c89b6ecce5d7c07bdaba23343bcc2a7e560",
+  "tile/entries-u32/042": "1ae42584df392dcd88d43862cc5f56ffac62e281632211c7c9512ca8bc5c99e3",
+  "tile/entries-u32/043": "9b07fadc87ff2bc3714c5bc323254fb34d7906d3b0acb71f6af173a9f6f7f59a",
+  "tile/entries-u32/044": "0064a80e681cc911bd2326357e3d3853e64b76f1fb7c7021636266e447990209",
+  "tile/entries-u32/045": "555139cbc8291c69428b670540b75307860017b42ac8aeeaedc0d0aa4215218e",
+  "tile/entries-u32/046": "5027c7dfc60a098230b1ac752c0b74ae8b72a1b0c8d35a8f5ab24ce2587e9c6d",
+  "tile/entries-u32/047": "3e5e3b6522a0bce0c8f63b55e454e68401db7b5c994850313d0fe2012fdecf91",
+  "tile/entries-u32/048": "4b3995640cf582f5680ad467685f5a2e91133e3dee3ee410994adcc9a20443a4",
+  "tile/entries-u32/049": "5ac44e23dec2f9d54f12c6f50d7a81562763041e46ad2062bffbddda7d9de1bf",
+  "tile/entries-u32/050": "2ffbcf34a0d27346a70b1b053640a70635281e6285146224aa42e7a7e1b4a8bc",
+  "tile/entries-u32/051": "60d3b889dafafaa3e9deadb15d02317dc5fac4bd263445bea654dcf629266493",
+  "tile/entries-u32/052": "026b135d83b3d2f293bb398867083e3d491b663edd4219ba0bfad62c84d66163",
+  "tile/entries-u32/053": "cebb00921a0d07af6563c5b98d129c24bf664a9824a543aa2d55802b10a9bb83",
+  "tile/entries-u32/054": "fa4dfb65e9f83b61d4c137c2b64c9fba5de679aee60e91d4050adcff515a0c64",
+  "tile/entries-u32/055": "10311efdbf69e0e25ba445ff06a1af085e1fbc6a1f761de09dade8c59a66f547",
+  "tile/entries-u32/056": "0a995b1a2374f89b0e005b84a59b52bdbe91661bbe19b3826372f28a2a2d3dd2",
+  "tile/entries-u32/057": "5307f34d1f7641aecb594d5dd5dd07df1a9c95f38bc58a0163d8b2cec7a2a29d",
+  "tile/entries-u32/058": "c98ab11e42a1cf3ed5cae6960eec5234e1e6374162c046e225e9cfdcabb3136b",
+  "tile/entries-u32/059.p/88": "a6ce7f0bd6b72adcdb158f72d7643252e4c64e5396476d0c67e9b4c23952bdf1"
+ },
+ "formats": {
+  "checkpoint": "c2sp.org/tlog-checkpoint + c2sp.org/signed-note (Ed25519, nom legion-mcp-tlog)",
+  "entries": "tile/entries-u32/<N>[.p/<W>] : suite d'entrées préfixées par leur longueur en uint32 big-endian ; chaque entrée = JCS (RFC 8785) d'un enregistrement signé ; haché de feuille = SHA-256(0x00 || entrée). Format alternatif car 9 entrées > 65535 octets (préfixe uint16 du format standard impossible).",
+  "hash_tiles": "c2sp.org/tlog-tiles : tile/<L>/<N>[.p/<W>], SHA-256 RFC 6962, largeur 256",
+  "keyring": "keyring.jsonl : entrée 0 = clé racine (son empreinte sha256 est l'ancre de confiance), puis sous-clés approuvées par la racine (endorsement_sig) avec preuve de possession (self_sig), chaînées par prev_hash"
+ },
+ "note": "Manifeste indicatif : resurrect.py ne lui fait pas confiance et recalcule tout depuis les tuiles.",
+ "origin": "tlog.legion-api.com/mcp/v0",
+ "root_sha256": "bf1e1b800d0424b103a7ee56221523ee777e5d85e614e0baabce92b5f0402a6f",
+ "schema": "legion-phoenix-export/0.1",
+ "tree_size": 15192
+}

tlog/resurrect.py

@@ -0,0 +1,480 @@
+#!/usr/bin/env python3
+"""RÉSURRECTION — reconstruit et vérifie le journal MCP LEGION depuis un miroir, sans aucun serveur LEGION.
+
+  python3 resurrect.py MIROIR_URL EMPREINTE_CLE_RACINE --out DOSSIER_VIDE [--bitcoin-node] [--json]
+
+Entrées : UNIQUEMENT l'URL d'un miroir (https://…, http://… ou file://…) et l'empreinte sha256 (64 hex) de la clé racine.
+Dépendances : Python 3.8+ et le paquet `cryptography` (Ed25519). Aucune ligne de code LEGION n'est importée.
+
+Contrôles (tout échec = code de sortie 1, rien n'est déclaré « réussi ») :
+  1. trousseau : l'entrée 0 a l'empreinte donnée ; chaque sous-clé est chaînée (prev_hash, hash), approuvée par la racine
+     et prouve la possession de sa clé ; révocations appliquées ;
+  2. checkpoint C2SP signé par une sous-clé « mcp-tlog » du trousseau (signed-note Ed25519) ;
+  3. chaque entrée : haché de feuille = tuile de niveau 0 ; JCS(entrée) identique octet pour octet ; leaf_index = position ;
+     signature Ed25519 de l'enregistrement valide avec la clé que le trousseau associe à son key_id ;
+  4. tuiles de niveau >= 1 recalculées depuis le niveau inférieur ; racine recalculée = racine du checkpoint ;
+  5. chaque tête signée de heads.jsonl : signature valide, racine = racine recalculée à sa taille, preuve de cohérence
+     RFC 6962 de cette taille vers le checkpoint calculée puis vérifiée ;
+  6. ancrages OpenTimestamps : head.canon.json = une tête signée vérifiée, le .ots engage bien sha256(head.canon.json),
+     blocs Bitcoin déclarés dans le .ots. Statut « sealed » UNIQUEMENT si `ots verify` réussit avec un nœud Bitcoin
+     (--bitcoin-node) ; sinon « pending ».
+"""
+import argparse
+import base64
+import hashlib
+import json
+import os
+import shutil
+import struct
+import subprocess
+import sys
+import time
+import urllib.parse
+import urllib.request
+
+TILE = 256
+LOG_NOTE_NAME = "legion-mcp-tlog"
+PURPOSE = "mcp-tlog"
+SIG_FIELDS = ("hash", "self_sig", "endorsement_sig")
+
+
+class Fail(Exception):
+    pass
+
+
+# ---------- JSON canonique RFC 8785 (JCS), sans flottants (le journal n'en contient pas : un flottant = échec explicite)
+def jcs(o):
+    if o is None:
+        return "null"
+    if o is True:
+        return "true"
+    if o is False:
+        return "false"
+    if isinstance(o, int):
+        if abs(o) > 2 ** 53:
+            raise Fail("JCS : entier hors de l'intervalle sûr")
+        return str(o)
+    if isinstance(o, float):
+        raise Fail("JCS : flottant non pris en charge par ce vérificateur")
+    if isinstance(o, str):
+        return json.dumps(o, ensure_ascii=False)
+    if isinstance(o, list):
+        return "[" + ",".join(jcs(x) for x in o) + "]"
+    if isinstance(o, dict):
+        return "{" + ",".join(json.dumps(k, ensure_ascii=False) + ":" + jcs(o[k])
+                              for k in sorted(o, key=lambda k: k.encode("utf-16-be"))) + "}"
+    raise Fail("JCS : type %r" % type(o))
+
+
+def canon(o):
+    return jcs(o).encode("utf-8")
+
+
+# ---------- Merkle RFC 6962 / 9162
+def leaf_hash(b):
+    return hashlib.sha256(b"\x00" + b).digest()
+
+
+def node_hash(a, b):
+    return hashlib.sha256(b"\x01" + a + b).digest()
+
+
+def _k(n):
+    k = 1
+    while k * 2 < n:
+        k *= 2
+    return k
+
+
+def mth(leaves):
+    n = len(leaves)
+    if n == 0:
+        return hashlib.sha256(b"").digest()
+    if n == 1:
+        return leaves[0]
+    k = _k(n)
+    return node_hash(mth(leaves[:k]), mth(leaves[k:]))
+
+
+def consistency_proof(m, leaves):
+    """RFC 6962 §2.1.2 SUBPROOF(m, D[n], true)."""
+    def sub(m, d, b):
+        n = len(d)
+        if m == n:
+            return [] if b else [mth(d)]
+        k = _k(n)
+        if m <= k:
+            return sub(m, d[:k], b) + [mth(d[k:])]
+        return sub(m - k, d[k:], False) + [mth(d[:k])]
+    return sub(m, leaves, True)
+
+
+def verify_consistency(m, n, old_root, new_root, proof):
+    """RFC 9162 §2.1.4.2."""
+    if m == n:
+        return not proof and old_root == new_root
+    if m == 0 or m > n:
+        return False
+    proof = list(proof)
+    if m & (m - 1) == 0:   # m puissance de 2
+        proof.insert(0, old_root)
+    fn, sn = m - 1, n - 1
+    while fn & 1:
+        fn >>= 1
+        sn >>= 1
+    if not proof:
+        return False
+    fr = sr = proof[0]
+    for c in proof[1:]:
+        if sn == 0:
+            return False
+        if fn & 1 or fn == sn:
+            fr = node_hash(c, fr)
+            sr = node_hash(c, sr)
+            while fn and not fn & 1:
+                fn >>= 1
+                sn >>= 1
+        else:
+            sr = node_hash(sr, c)
+        fn >>= 1
+        sn >>= 1
+    return fr == old_root and sr == new_root and sn == 0
+
+
+# ---------- tuiles C2SP
+def tile_path(level, n, width=TILE):
+    s = "%d" % n
+    s = "0" * ((-len(s)) % 3) + s
+    parts = [s[i:i + 3] for i in range(0, len(s), 3)]
+    return "%s/%s" % (level, "/".join(["x" + x for x in parts[:-1]] + [parts[-1]])) + (".p/%d" % width if width < TILE else "")
+
+
+# ---------- Ed25519
+def ed_verify(pub_raw, sig, msg):
+    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+    try:
+        Ed25519PublicKey.from_public_bytes(pub_raw).verify(sig, msg)
+        return True
+    except Exception:
+        return False
+
+
+def b64(s):
+    return base64.b64decode(s, validate=True)
+
+
+# ---------- trousseau
+def load_keyring(text, root_pin):
+    keys, revoked, limits, compromised = {}, set(), {}, set()
+    prev, root_pub = None, None
+    for n, line in enumerate(l for l in text.splitlines() if l.strip()):
+        e = json.loads(line)
+        if n == 0:
+            if e.get("type") != "key_register" or e.get("alg") != "Ed25519" or \
+                    hashlib.sha256(b64(e["public_key_b64"])).hexdigest() != root_pin:
+                raise Fail("trousseau : l'entrée 0 n'est pas la clé racine d'empreinte %s" % root_pin)
+            root_pub = b64(e["public_key_b64"])
+            keys[root_pin] = dict(e, purpose="root")
+            prev = e.get("hash") or hashlib.sha256(canon({k: v for k, v in e.items() if k not in SIG_FIELDS})).hexdigest()
+            continue
+        body = canon({k: v for k, v in e.items() if k not in SIG_FIELDS})
+        if e.get("prev_hash") != prev or e.get("hash") != hashlib.sha256(body).hexdigest():
+            raise Fail("trousseau : chaîne rompue à l'entrée %d" % n)
+        if not ed_verify(root_pub, b64(e.get("endorsement_sig", "")), body):
+            raise Fail("trousseau : entrée %d non approuvée par la racine" % n)
+        if e["type"] == "key_register":
+            pub = b64(e["public_key_b64"])
+            pin = hashlib.sha256(pub).hexdigest()
+            if e.get("alg") != "Ed25519" or e.get("key_id") != "k1:" + pin[:32]:
+                raise Fail("trousseau : key_id incohérent à l'entrée %d" % n)
+            if not ed_verify(pub, b64(e.get("self_sig", "")), body):
+                raise Fail("trousseau : preuve de possession absente à l'entrée %d" % n)
+            keys[pin] = e
+        elif e["type"] == "key_revoke":
+            revoked.add(e["key_id"])
+            if isinstance(e.get("valid_until_tree_size"), int):
+                limits[e["key_id"]] = min(e["valid_until_tree_size"], limits.get(e["key_id"], e["valid_until_tree_size"]))
+            else:
+                limits.pop(e["key_id"], None)
+                compromised.add(e["key_id"])
+        else:
+            raise Fail("trousseau : type inconnu %r" % e["type"])
+        prev = e["hash"]
+    if root_pub is None:
+        raise Fail("trousseau vide")
+
+    def pub_for(pin, purpose, leaf_index=None, tree_size=None):
+        e = keys.get(pin)
+        if e is None:
+            return None
+        kid = "k1:" + pin[:32]
+        if kid in revoked:
+            lim = None if kid in compromised else limits.get(kid)
+            if lim is None or not ((leaf_index is not None and leaf_index < lim) or (tree_size is not None and tree_size <= lim)):
+                return None
+        if e.get("purpose") not in (purpose, "root"):
+            return None
+        return b64(e["public_key_b64"])
+    return keys, pub_for
+
+
+def note_key_id(name, pub_raw, kind=0x01):
+    return hashlib.sha256(name.encode() + b"\n" + bytes([kind]) + pub_raw).digest()[:4]
+
+
+# ---------- OpenTimestamps (lecture du .ots, sans confiance : seul `ots verify` + nœud scelle)
+OTS_MAGIC = b"\x00OpenTimestamps\x00\x00Proof\x00\xbf\x89\xe2\xe8\x84\xe8\x92\x94"
+BTC_TAG = bytes.fromhex("0588960d73d71901")
+
+
+def ots_info(ots):
+    if not ots.startswith(OTS_MAGIC):
+        raise Fail(".ots : en-tête invalide")
+    p = len(OTS_MAGIC) + 1          # + octet de version
+    if ots[p] != 0x08:               # op SHA256
+        raise Fail(".ots : le fichier n'engage pas un sha256")
+    digest = ots[p + 1:p + 33]
+    blocks, i = [], 0
+    while True:
+        i = ots.find(BTC_TAG, i)
+        if i < 0:
+            break
+        j = i + len(BTC_TAG)
+        ln, sh, k = 0, 0, j       # varuint de la longueur de charge utile
+        while True:
+            b = ots[k]; ln |= (b & 0x7f) << sh; k += 1; sh += 7
+            if not b & 0x80:
+                break
+        h, sh, q = 0, 0, k
+        while q < k + ln:
+            b = ots[q]; h |= (b & 0x7f) << sh; q += 1; sh += 7
+            if not b & 0x80:
+                break
+        blocks.append(h)
+        i = j
+    return digest, sorted(set(blocks))
+
+
+# ---------- récupération
+# Redirections (ex. CDN de Hugging Face) : suivies, comptées et rapportées. Aucune confiance accordée à l'hôte final :
+# chaque octet reçu est vérifié par les hachés de Merkle, la racine signée et les signatures (contrôles 2 à 6).
+REDIRECTS = {"count": 0, "hosts": {}}
+
+
+class _CountRedirects(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        REDIRECTS["count"] += 1
+        h = urllib.parse.urlsplit(newurl).hostname or "?"
+        REDIRECTS["hosts"][h] = REDIRECTS["hosts"].get(h, 0) + 1
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+_OPENER = urllib.request.build_opener(_CountRedirects)
+
+
+def fetch(base, path, required=True):
+    url = base.rstrip("/") + "/" + path
+    try:
+        with _OPENER.open(urllib.request.Request(url, headers={"User-Agent": "legion-resurrect/0.1",
+                                                               "Accept-Encoding": "identity"}), timeout=60) as r:
+            return r.read()
+    except Exception as e:
+        if required:
+            raise Fail("récupération impossible : %s (%s)" % (url, e))
+        return None
+
+
+def resurrect(mirror, root_pin, out, bitcoin_node=False, log=print):
+    t0 = time.time()
+    REDIRECTS.update(count=0, hosts={})
+    root_pin = root_pin.lower()
+    if len(root_pin) != 64 or any(c not in "0123456789abcdef" for c in root_pin):
+        raise Fail("empreinte racine : 64 caractères hexadécimaux attendus")
+    if os.path.exists(out) and os.listdir(out):
+        raise Fail("le dossier de sortie doit être vide : %s" % out)
+    os.makedirs(out, exist_ok=True)
+    rep = {"mirror": mirror, "root_pin": root_pin, "checks": {}}
+    C = rep["checks"]
+
+    kr_text = fetch(mirror, "keyring.jsonl").decode("utf-8")
+    keys, pub_for = load_keyring(kr_text, root_pin)
+    C["keyring_chain"] = "ok : %d clés (racine + %d sous-clés)" % (len(keys), len(keys) - 1)
+    log("[1] trousseau vérifié depuis la racine épinglée :", C["keyring_chain"])
+
+    note = fetch(mirror, "checkpoint").decode("utf-8")
+    body, _, sigs = note.partition("\n\n")
+    body += "\n"
+    lines = body.split("\n")
+    origin, size, root = lines[0], int(lines[1]), b64(lines[2])
+    signed_by = None
+    for sl in sigs.splitlines():
+        if not sl.startswith("— "):
+            continue
+        name, sb = sl[2:].rsplit(" ", 1)
+        raw = b64(sb)
+        for pin, e in keys.items():
+            pub = pub_for(pin, PURPOSE, tree_size=size)
+            if pub and name == LOG_NOTE_NAME and raw[:4] == note_key_id(name, pub) and ed_verify(pub, raw[4:], body.encode()):
+                signed_by = pin
+    if not signed_by:
+        raise Fail("checkpoint : aucune signature valide d'une clé mcp-tlog du trousseau")
+    C["checkpoint"] = "ok : %s taille %d racine %s signé par %s" % (origin, size, root.hex(), signed_by)
+    log("[2] checkpoint signé :", C["checkpoint"])
+
+    leaves, entries = [], []
+    for t in range((size + TILE - 1) // TILE):
+        w = min(TILE, size - t * TILE)
+        lvl0 = fetch(mirror, "tile/" + tile_path(0, t, w))
+        bundle = fetch(mirror, "tile/entries-u32/" + tile_path(0, t, w)[2:])
+        if len(lvl0) != 32 * w:
+            raise Fail("tuile 0/%d : %d octets, %d attendus" % (t, len(lvl0), 32 * w))
+        p, k = 0, 0
+        while p < len(bundle):
+            (ln,) = struct.unpack(">I", bundle[p:p + 4])
+            e = bundle[p + 4:p + 4 + ln]
+            if len(e) != ln:
+                raise Fail("paquet d'entrées %d tronqué" % t)
+            if leaf_hash(e) != lvl0[32 * k:32 * k + 32]:
+                raise Fail("entrée %d : haché de feuille différent de la tuile de niveau 0" % (t * TILE + k))
+            entries.append(e)
+            leaves.append(lvl0[32 * k:32 * k + 32])
+            p += 4 + ln
+            k += 1
+        if k != w:
+            raise Fail("paquet d'entrées %d : %d entrées, %d attendues" % (t, k, w))
+    C["entries_vs_level0_tiles"] = "ok : %d entrées, chacune hachée = tuile de niveau 0" % len(entries)
+    log("[3] entrées :", C["entries_vs_level0_tiles"])
+
+    # niveaux supérieurs : chaque tuile servie doit égaler le recalcul
+    level, L, n_up = list(leaves), 0, 0
+    while True:
+        full = len(level) // TILE
+        nxt = []
+        for t in range(full):
+            h = level[t * TILE:(t + 1) * TILE]
+            while len(h) > 1:
+                h = [node_hash(h[i], h[i + 1]) for i in range(0, len(h), 2)]
+            nxt.append(h[0])
+        if not nxt:
+            break
+        L += 1
+        for t in range((len(nxt) + TILE - 1) // TILE):
+            chunk = nxt[t * TILE:(t + 1) * TILE]
+            if fetch(mirror, "tile/" + tile_path(L, t, len(chunk))) != b"".join(chunk):
+                raise Fail("tuile %d/%d différente du recalcul" % (L, t))
+            n_up += 1
+        level = nxt
+    recomputed = mth(leaves)
+    if recomputed != root:
+        raise Fail("racine recalculée %s != racine signée %s" % (recomputed.hex(), root.hex()))
+    C["root"] = "ok : racine recalculée = racine signée = %s (%d tuile(s) de niveau >= 1 vérifiées)" % (root.hex(), n_up)
+    log("[4] racine :", C["root"])
+
+    recs = []
+    for i, e in enumerate(entries):
+        r = json.loads(e)
+        if canon(r) != e:
+            raise Fail("entrée %d : JSON non canonique (JCS)" % i)
+        if r.get("leaf_index") != i:
+            raise Fail("entrée %d : leaf_index %r (séquence rompue)" % (i, r.get("leaf_index")))
+        pub = pub_for(r.get("key_id", ""), PURPOSE, leaf_index=i)
+        body_r = canon({k: v for k, v in r.items() if k != "signature_ed25519"})
+        if pub is None or not ed_verify(pub, b64(r.get("signature_ed25519", "")), body_r):
+            raise Fail("entrée %d : signature invalide ou clé non autorisée (%s)" % (i, r.get("key_id")))
+        recs.append(r)
+    by_key = {}
+    for r in recs:
+        by_key[r["key_id"][:16]] = by_key.get(r["key_id"][:16], 0) + 1
+    C["records"] = "ok : %d enregistrements signés, séquence 0..%d sans trou ; clés %s" % (len(recs), len(recs) - 1, by_key)
+    log("[5] enregistrements :", C["records"])
+
+    heads_raw = fetch(mirror, "heads.jsonl").decode("utf-8")
+    heads = {}
+    for line in heads_raw.splitlines():
+        if not line.strip():
+            continue
+        h = json.loads(line)
+        th = h["tree_head"]
+        m = th["tree_size"]
+        pub = pub_for(th["issuer_pin_sha256"], PURPOSE, tree_size=m)
+        if pub is None or not ed_verify(pub, b64(h["signature_ed25519"]), canon(th)):
+            raise Fail("tête %d : signature invalide" % m)
+        if m > size or mth(leaves[:m]).hex() != th["root_sha256"]:
+            raise Fail("tête %d : racine différente du journal reconstruit" % m)
+        proof = consistency_proof(m, leaves)
+        if not verify_consistency(m, size, bytes.fromhex(th["root_sha256"]), root, proof):
+            raise Fail("tête %d : preuve de cohérence vers %d invalide" % (m, size))
+        heads[m] = th
+    C["signed_heads"] = "ok : têtes %s, signatures valides, cohérentes avec le checkpoint %d (preuves RFC 6962 vérifiées)" % (sorted(heads), size)
+    log("[6] têtes signées :", C["signed_heads"])
+
+    manifest = json.loads(fetch(mirror, "phoenix.json", required=False) or b"{}")
+    anchors = []
+    for m in manifest.get("anchors", []):
+        hc = fetch(mirror, "anchors/%d/head.canon.json" % m)
+        ots = fetch(mirror, "anchors/%d/head.canon.json.ots" % m, required=False)
+        th = json.loads(hc)
+        if canon(th) != hc or heads.get(m) != th:
+            raise Fail("ancrage %d : head.canon.json n'est pas une tête signée vérifiée" % m)
+        a = {"tree_size": m, "root": th["root_sha256"], "consistent_with_checkpoint": True}
+        if ots is None:
+            a.update(status="absent")
+        else:
+            digest, blocks = ots_info(ots)
+            if digest != hashlib.sha256(hc).digest():
+                raise Fail("ancrage %d : le .ots n'engage pas sha256(head.canon.json)" % m)
+            a.update(ots_commits_head=True, bitcoin_blocks_declared=blocks, status="pending",
+                     status_detail="blocs déclarés dans le .ots, non vérifiés par un nœud Bitcoin complet")
+            if bitcoin_node and shutil.which("ots"):
+                d = os.path.join(out, "anchors", str(m))
+                os.makedirs(d, exist_ok=True)
+                open(os.path.join(d, "head.canon.json"), "wb").write(hc)
+                open(os.path.join(d, "head.canon.json.ots"), "wb").write(ots)
+                r = subprocess.run(["ots", "verify", "-f", os.path.join(d, "head.canon.json"), os.path.join(d, "head.canon.json.ots")],
+                                   capture_output=True, text=True, timeout=300)
+                if r.returncode == 0 and "Success" in (r.stdout + r.stderr):
+                    a.update(status="sealed", status_detail="ots verify réussi avec un nœud Bitcoin")
+                else:
+                    a.update(status_detail="ots verify non concluant : %s" % (r.stdout + r.stderr).strip()[-200:])
+        anchors.append(a)
+        log("[7] ancrage %d : %s %s" % (m, a["status"], a.get("bitcoin_blocks_declared", "")))
+    C["anchors"] = anchors or "aucun ancrage annoncé par le miroir"
+
+    # le journal renaît : écriture dans le dossier vide
+    with open(os.path.join(out, "records.jsonl"), "w", encoding="utf-8") as f:
+        for e in entries:
+            f.write(e.decode("utf-8") + "\n")
+    open(os.path.join(out, "heads.jsonl"), "w", encoding="utf-8").write(heads_raw)
+    open(os.path.join(out, "keyring.jsonl"), "w", encoding="utf-8").write(kr_text)
+    open(os.path.join(out, "checkpoint"), "w", encoding="utf-8").write(note)
+    rep["redirects"] = {"count": REDIRECTS["count"], "hosts": dict(REDIRECTS["hosts"]),
+                        "note": "contenu redirigé vérifié par Merkle + signatures, comme le reste"}
+    rep.update(result="RÉSURRECTION RÉUSSIE", origin=origin, tree_size=size, root_sha256=root.hex(),
+               signed_by=signed_by, elapsed_s=round(time.time() - t0, 1),
+               finished_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))
+    json.dump(rep, open(os.path.join(out, "resurrection_report.json"), "w"), indent=1, ensure_ascii=False)
+    return rep
+
+
+def main(argv):
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("mirror")
+    ap.add_argument("root_pin")
+    ap.add_argument("--out", required=True)
+    ap.add_argument("--bitcoin-node", action="store_true", help="tenter `ots verify` (nœud Bitcoin Core requis)")
+    ap.add_argument("--json", action="store_true")
+    a = ap.parse_args(argv)
+    quiet = (lambda *x: None) if a.json else print
+    try:
+        rep = resurrect(a.mirror, a.root_pin, a.out, a.bitcoin_node, quiet)
+    except Fail as e:
+        rep = {"result": "RÉSURRECTION ÉCHOUÉE", "mirror": a.mirror, "error": str(e)}
+        print(json.dumps(rep, ensure_ascii=False) if a.json else "ÉCHEC : %s" % e)
+        return 1
+    print(json.dumps(rep, ensure_ascii=False) if a.json else
+          "%s : %s taille %d racine %s (%.1f s)" % (rep["result"], rep["origin"], rep["tree_size"], rep["root_sha256"], rep["elapsed_s"]))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))