Add distinct winners, frozen evaluation and private-bucket recipes

BINARY_PROVENANCE.json

@@ -1,72 +1 @@
-{
-  "artifact_origins": {
-    "bin/altd-sim": {
-      "actions_run_id": 38203558700,
-      "archive_member": "altd-sim-nightly-x86_64-unknown-linux-gnu/altd-sim",
-      "bytes": 15774792,
-      "evidence_path": "build/receipts/upstream-altd-sim-nightly-x86_64-unknown-linux-gnu.tar.gz",
-      "evidence_sha256": "15ddf3cc8748a13ab123226ed328fb65acfaade08351f97a93686223aa2cceed",
-      "origin_type": "github_actions_archive_member",
-      "run_conclusion": "success",
-      "sha256": "0135ecc3d435a9d327be7a92e048cfb5c5291a02ef1e0dddd6ead1cc19b31166",
-      "source_archive_sha256": "15ddf3cc8748a13ab123226ed328fb65acfaade08351f97a93686223aa2cceed",
-      "source_repository": "https://github.com/Zorro909/driving_sim_rs",
-      "source_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"
-    },
-    "bin/extract_saved_track": {
-      "build_receipt_path": "cpu/IMPORTER_BUILD_RECEIPT.json",
-      "build_receipt_sha256": "4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d",
-      "bytes": 3247776,
-      "compatibility_receipt": "build/receipts/build-receipt.json",
-      "evidence_path": "cpu/IMPORTER_BUILD_RECEIPT.json",
-      "evidence_sha256": "4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d",
-      "origin_type": "retained_verified_importer_binary",
-      "sha256": "3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a",
-      "source_repository": "https://github.com/Zorro909/driving_sim_rs",
-      "source_revision": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f"
-    },
-    "bin/libaltd_gpu.so": {
-      "build_command": "CUDA_ARCH=sm_86,sm_120 OUT=/work/artifacts/gpu bash /work/source/gpu/build-cuda.sh",
-      "build_log_path": "build/receipts/cuda-build.log",
-      "build_log_sha256": "c4ea4bde35aa972644dd3d6ad7511d097736547ab2afb216920e67b26d954be6",
-      "builder_image": "nvidia/cuda:13.0.2-devel-ubuntu22.04",
-      "builder_image_digest": "sha256:1c517d4fb96528c8999e14e6e6b16d7e2ff9ae8d194fd788d60fdc88e693e982",
-      "bytes": 4711704,
-      "compiled_architectures": [
-        "sm_86",
-        "sm_120",
-        "compute_120 PTX"
-      ],
-      "evidence_path": "build/source-b90b8af.tar.gz",
-      "evidence_sha256": "e9e561c6d9c56cedf344aaf9d91f584a4d5730ccd26ac5a2bfa23c3eed9204e6",
-      "origin_type": "local_cuda_build",
-      "sha256": "3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca",
-      "source_archive_path": "build/source-b90b8af.tar.gz",
-      "source_archive_sha256": "e9e561c6d9c56cedf344aaf9d91f584a4d5730ccd26ac5a2bfa23c3eed9204e6",
-      "source_repository": "https://github.com/Zorro909/driving_sim_rs",
-      "source_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"
-    }
-  },
-  "artifacts": {
-    "bin/altd-sim": {
-      "bytes": 15774792,
-      "sha256": "0135ecc3d435a9d327be7a92e048cfb5c5291a02ef1e0dddd6ead1cc19b31166"
-    },
-    "bin/extract_saved_track": {
-      "bytes": 3247776,
-      "sha256": "3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a"
-    },
-    "bin/libaltd_gpu.so": {
-      "bytes": 4711704,
-      "sha256": "3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca"
-    }
-  },
-  "build_receipt": "../build/receipts/build-receipt.json",
-  "build_receipt_sha256": "789806b8d70b73a718e889fb202171c18b50070e04a70ab57af9b93d0ad58a76",
-  "github_actions_run": 38203558700,
-  "importer_source_revision": "d8ab74c25df70b6a86ed101080e33d5fb785ea6f",
-  "note": "The simulator is the exact b90 Linux Actions artifact; the CUDA library is built from the same b90 source for sm_86 and sm_120 with compute_120 PTX. Rust/C layout ABI validation passed. No CUDA device or kernel execution was available in the local builder; hosted CUDA qualification remains separate. The retained d8 track importer is separately identified and bounded compatibility is linked.",
-  "run_conclusion": "success",
-  "source_repository": "https://github.com/Zorro909/driving_sim_rs",
-  "source_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"
-}
+{"artifact_origins":{"bin/altd-sim":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","bytes":3580296,"origin_type":"local_linux_build","patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","sha256":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d","source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"},"bin/extract_saved_track":{"build_receipt_path":"IMPORTER_BUILD_RECEIPT.json","build_receipt_sha256":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","bytes":3247776,"compatibility_receipt_path":"native/build-receipt.json","compatibility_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","evidence_path":"IMPORTER_BUILD_RECEIPT.json","evidence_sha256":"4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d","origin_type":"retained_verified_importer_binary","sha256":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a","source_repository":"https://github.com/Zorro909/driving_sim_rs","source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f"},"bin/libaltd_gpu.so":{"build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","bytes":4711704,"origin_type":"retained_cuda_b90","patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca","source_receipt_sha256":"33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}},"artifacts":{"bin/altd-sim":{"bytes":3580296,"sha256":"6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d"},"bin/extract_saved_track":{"bytes":3247776,"sha256":"3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a"},"bin/libaltd_gpu.so":{"bytes":4711704,"sha256":"3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca"}},"build_receipt":"native/build-receipt.json","build_receipt_path":"native/build-receipt.json","build_receipt_sha256":"b2336433fc14ddf8b7722faa8ca434eff6f73ec41ec6d48cc0e9bf230f5efb3d","importer_source_revision":"d8ab74c25df70b6a86ed101080e33d5fb785ea6f","native_patch_sha256":"56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63","note":"The simulator is a fresh Linux build from b90 plus the hashed local analysis patch. The CUDA library is retained b90 and has layout ABI evidence only; this package does not claim local GPU kernel execution. The track importer remains separately identified with bounded compatibility evidence.","source_repository":"https://github.com/Zorro909/driving_sim_rs","source_revision":"b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0"}

BUCKET_BUNDLE.md

@@ -1,4 +1,4 @@
-# Portable bucket bundle v1
+# Portable bucket bundles v1 and v2
 
 The browser supports explicit local-file export/import and optional direct save/restore to an existing private bucket. Local export downloads one JSON bundle. Restore validates the complete bundle before staging the network and any optional track or recipe in the current page. A restored receipt is kept in page memory and offered as a separate download. Restore never starts a run or writes browser storage.
 
@@ -6,11 +6,21 @@ Bucket storage starts disconnected. After an explicit HF OAuth authorization for
 
 ## Envelope
 
-The only top-level fields are `schema`, `version`, and `artifacts`. The schema is `ald.portable-bundle`, version `1`. The required artifact slot is `selected_network`; optional fixed slots are `selected_track`, `selected_recipe`, and `run_receipt`. Unknown slots or fields are rejected.
+The only top-level fields are `schema`, `version`, and `artifacts`. The schema is `ald.portable-bundle`. Legacy version `1` remains readable. Version `2` adds a validated analysis archive for new training and frozen-evaluation results. The required artifact slot is `selected_network`; optional fixed slots are `selected_track`, `selected_recipe`, and `run_receipt`. Version 2 also carries `analysis_archive`. Unknown slots or fields are rejected.
 
 - A network stores its original `.evolution` bytes as base64 with byte length, SHA-256, format `evolution`, and kind `input` or `result`. The page validates decoded network content with its existing game-network validator and keeps the original bytes when staging it.
 - A track stores original `.track` bytes with length and SHA-256. A built-in track also records its catalog ID and display label; an uploaded track has no extra identifying metadata.
 - A recipe stores only version, A–J slot, name, and the existing validated training settings. Restore stages it into the form; saving it to the browser recipe library remains a separate user action.
-- A run receipt is an allowlisted summary only: build ID, backend, output hash, whitelisted report fields for vehicle, counts, metrics, file hashes, and settings, plus up to 1,000 validated generation-history rows. It excludes paths, filenames, usernames, account data, job IDs/keys, and raw errors. Receipts that do not match the bundled network or included track are omitted on export or rejected on import. A connected auto-save bundles the exact verified run output, its captured input track, and matching run receipt.
+- A run receipt is an allowlisted summary only: build ID, backend, output hash, whitelisted report fields for vehicle, counts, metrics, file hashes, and settings, plus up to 1,000 validated generation-history rows. It excludes paths, filenames, usernames, account data, job IDs/keys, and raw errors. Legacy receipts must match the bundled network and included track. With v2, the selected network may be any manifested winner; the run receipt retains the original fitness-result identity, and the validator checks both bindings independently. Frozen evaluation binds the selected network to its unchanged input. A connected auto-save bundles the exact verified run output, its captured input track, and matching run receipt.
 
-Caps are 4 MiB for network bytes, 1 MiB for track bytes, 32 KiB for recipe JSON, 512 KiB for receipt JSON, and 8 MiB for the complete bundle. Payload bytes and hashes must match exactly.
+Caps are 4 MiB for network bytes, 1 MiB for track bytes, 32 KiB for recipe JSON, 512 KiB for receipt JSON, and 48 MiB for the complete bundle. Payload bytes and hashes must match exactly.
+
+## Analysis archive
+
+The v2 `artifacts.analysis_archive` slot has `format: "ald.run-analysis-archive+gzip"`, `bytes`, `sha256`, and `data_base64`. Its bounded gzip payload expands to one JSON envelope with schema `ald.run-analysis-archive`, version 1, and a list of fixed-name files. Each entry carries its name, byte count, SHA-256 and base64 contents. The compressed cap is 32 MiB; expanded JSON is capped at 256 MiB, with an aggregate 192 MiB cap on decoded members to leave room for base64 overhead. Descriptors contain at most 128,000 complete car observations. Exceeding a limit is an error, never permission to truncate.
+
+Required members are `analysis.json` and `descriptors.jsonl`. Train results include `winners/fitness.evolution`, plus fastest-lap and clean-lap files only when those categories have qualifying candidates. Frozen evaluation includes `evaluation.json` and no new winner files. Descriptors use the exact 18-channel order declared by the analysis manifest, storing compact value, population-relative rank, and unavailable-reason arrays.
+
+Bucket saves preserve the canonical bundle, readable report/history, compressed archive, complete descriptor and metadata files, and individual winner networks. Every uploaded object is read back and checked before saving is reported as verified. Files live under a new run-specific prefix. The app never deletes existing bucket content or overwrites a previous run.
+
+The local CLI can include a downloaded archive with `pack --analysis`; unpacking v2 restores its fixed analysis subdirectories into a new destination. Remote CLI operations remain explicit and use the local HF credential store.

DATA_POLICY.md

@@ -34,16 +34,17 @@ The browser holds a random job access key in memory, independently of optional H
 Anyone who obtains that key can access the job; do not share it. Reloading the
 page loses access. Expiry is fixed at five minutes from result publication.
 
-Automatic deletion is the default. The browser validates the complete download
-and acknowledges receipt; that deletes the result store's copy. One server
-download attempt is permitted in the default mode. We cannot verify that the
-browser saved to disk. An interrupted default-mode download is not retryable;
-Delete now and fixed expiry still work. Visitors can opt in for each single run
-to keep its result in application memory for repeat downloads until the same
-five-minute deadline when bucket autosave is disconnected or off. The checkbox resets after every run. Batch runs always
-use automatic deletion. Delete now removes a stored result immediately, and
-downloads never reset expiry. The browser can also save its received result
-again from page memory.
+Automatic deletion is the default. New results contain a primary network and a
+complete analysis archive. The browser verifies the size and hash of both before
+acknowledging receipt; that acknowledgment deletes both stored payloads together.
+Both remain retryable under the same job key until acknowledgment or the fixed
+five-minute expiry. Retrying does not extend expiry. Older primary-only result
+paths retain their one-attempt automatic delivery rule. We cannot verify that the
+browser saved to disk. Delete now removes the entire result immediately.
+Visitors can opt in for each single run to keep its result in application memory
+until the same deadline when bucket autosave is disconnected or off. The checkbox
+resets after every run. Batch and comparison runs use automatic deletion.
+The browser can save received networks and analysis again from page memory.
 
 Access is refused at the deadline. While the server is running, the expiry loop
 releases expired stored data within approximately one second, subject to runtime
@@ -118,8 +119,8 @@ The displayed value is an insertion-position estimate against the fetched raw gl
 
 ## Optional private bucket storage
 
-Bucket storage starts disconnected. After an explicit HF OAuth authorization and connection to an existing private bucket, automatic saving is on by default and can be turned off for manual saves. With no connection or autosave turned off, completed runs make no bucket storage calls. With autosave enabled, each completed run is downloaded and hash-verified in the browser, then the application confirms deletion of the server result before it sends the resulting network and sanitized run report to the bucket. Each batch result is saved before the next run starts; a save failure stops the batch. A failed receive has no verified local copy; a deletion-acknowledgment failure skips bucket saving; after confirmed deletion, an unconfirmed bucket save leaves the verified local candidate available for download or manual retry. A remote save might have completed if its response could not be verified.
+Bucket storage starts disconnected. After an explicit HF OAuth authorization and connection to an existing private bucket, automatic saving is on by default and can be turned off for manual saves. With no connection or autosave turned off, completed runs make no bucket storage calls. With autosave enabled, each completed run is downloaded and hash-verified in the browser, then the application confirms deletion of both server payloads before it sends the resulting network, available winner networks, complete per-car measurements and sanitized run report to the bucket. Each batch result is saved before the next run starts; a save failure stops the batch. A failed receive has no verified local copy; a deletion-acknowledgment failure skips bucket saving; after confirmed deletion, an unconfirmed bucket save leaves the verified local candidate available for download or manual retry. A remote save might have completed if its response could not be verified.
 
 HF describes the requested `write-repos` scope as read/write access to personal repositories. This grant is broader than one selected bucket and has not been confirmed as bucket-only or the minimum required scope. The token and bundle pass through this app server during storage operations; the app keeps the token in page memory only and removes temporary storage files after operations. It does not save tokens in URLs, browser storage, receipts or bundles. Disconnect, observed authorization denial/expiry, and page close clear the app's connection. The app has no bucket create, delete, overwrite or visibility controls; saved objects remain in the user's bucket until managed elsewhere. Provider-side logs and retention are outside app cleanup guarantees, which do not establish provider-wide zero data retention or secure physical erasure.
 
-Connecting checks the listed bundles and selects the newest compatible entry among those returned. It restores the entry in this page only when there is no existing network, track, result or editor draft; otherwise it only selects it. The list is bounded, so an incomplete scan may omit a newer bundle. No run starts automatically. Reports contain only fields returned by the engine, including generation history and configured settings; reward weights are not reported as per-reward contributions.
+Connecting checks the listed bundles and selects the newest compatible entry among those returned. It restores the entry in this page only when there is no existing network, track, result or editor draft; otherwise it only selects it. The list is bounded, so an incomplete scan may omit a newer bundle. No run starts automatically. Reports contain fields returned by the engine, including generation history and configured settings. New result archives also include all supported per-car reward measurements, update counts and within-population ranks. These ranks and configured reward weights are labeled separately; they are not absolute cross-run performance scores. Frozen evaluation preserves the input network and records a separate fresh driving result.

FRONTEND_SOURCE.json

@@ -1,10 +1 @@
-{
-  "source": "Runner r14 single-engine browser UI; selected .track tile renderer added from simulator atlas",
-  "source_sha256": "65d1e5f2c4e19b4951b828e82510005ab99a5270cf3dcb9f4eaa0fa1af8c40f8",
-  "output_sha256": "a145fbb303a85c728a530d98fbea998677c1c62a2589c46af9b8b287e4ce1f48",
-  "scope": "Frontend only; no engine, private data, track assets, API calls or storage copied",
-  "status": "Reviewed candidate with optional HF bucket OAuth, connected autosave, unique exports, player reports and latest-network picker; hosted qualification recorded separately",
-  "track_atlas_sha256": "d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4",
-  "client_sha256": "7e4bea3b9d2ffa79533ff6abed54481a3a6530e8152093f388e229c621bed9ec",
-  "track_map_sha256": "ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0"
-}
+{"base_provenance":{"output_sha256":"a145fbb303a85c728a530d98fbea998677c1c62a2589c46af9b8b287e4ce1f48","scope":"Frontend only; no engine, private data, track assets, API calls or storage copied","source":"Runner r14 single-engine browser UI; selected .track tile renderer added from simulator atlas","source_sha256":"65d1e5f2c4e19b4951b828e82510005ab99a5270cf3dcb9f4eaa0fa1af8c40f8"},"identity_note":"The historical source fields describe the base frontend; local packaged file hashes describe this candidate's derived frontend.","local_customization_id":"v1.2-winners-frozen-evaluation","packaged_frontend_files":{"assets/track-atlas.json":"d97c8900e3e5fb17734b5bd61d1f4f4b196d9be30af9848e2e273ae7e4079ae4","client.js":"946f06d308503a40c9048f07cda5cc580e58556a81e3e3430d9941fe9c2d7c3b","hf-auth.js":"3f3938bbc0935e4e9230c094029ef46e03beea74be199887c50e053e03dafcfe","index.html":"c46f7ba6dccf473956e038bf2028ff6d88b494a49d0c04c7ec0e278fd8eec0b3","track-library.js":"351ec4c026b49420ce963f4310cb000d9e987fd28e6dac5ecd0176509340f6e6","track-map.js":"ab5374aa49c7ccec90a787ee8c56cd71beb56b903bf2bbc322783e6f43c009f0"},"packaged_frontend_sha256":"df48f73011ef440936d4cb7cc2913db5c14e2a40652aa7090a08dc90ad2ad43c"}

README.md

@@ -17,3 +17,7 @@ The selected track map previews tile layout and asphalt/dirt/ice directly from t
 Application-controlled inputs and intermediate files are temporary. Outputs are held in memory for at most five minutes and deleted sooner after verified download by default; a single-run visitor may explicitly keep the result until that five-minute deadline. This is not a provider-wide zero-data-retention guarantee. Read DATA_POLICY.md and TRACK_LIBRARY.md. Upstream code and license: https://github.com/Zorro909/driving_sim_rs. Open upstream PRs 19 and 21 are not included.
 
 Feedback issues: https://github.com/seeker-cyber-maker/driving_sim_rs/issues/new.
+
+## Candidate: outcome archives and frozen evaluation
+
+This revision adds distinct fitness, fastest-lap and clean-lap network snapshots; per-car measurements for all supported reward channels; and evaluation without changing weights. Connected bucket saves include the analysis and winner files. See WINNERS_AND_EVALUATION.md for criteria, comparison limits and data handling. The original recipe remains user-controlled. Build-specific acceptance and hosted qualification are recorded separately.

RELEASE_MANIFEST.json

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

STORAGE_BOUNDARY.md

@@ -11,9 +11,9 @@ same settings contract is used independently of the selected storage policy.
 | Selected built-in track | Synchronized selectors and one verified Blob | Page memory across runs; no cookie, recipe or localStorage persistence |
 | Worker inputs / intermediate files | Temporary directory | Removed before successful result publication |
 | GPU pending inputs | Opaque single-use ticket plus memory store | Dispatch, confirmed quota-rejection discard, fixed 120-second expiry, or shutdown |
-| Single-run output | Memory result store and random job key | Default receipt ACK; opt-in repeat download until fixed five-minute expiry; manual delete or shutdown |
+| Single-run network and analysis | One memory result record and random job key; both payloads share expiry and deletion | Default receipt ACK; opt-in repeat download until fixed five-minute expiry; manual delete or shutdown |
 | Batch intermediates | Same job contract, always automatic | Verified size/hash and deletion ACK before advancement |
-| Received candidate / receipt | Browser page memory | Explicit discard, replacement, page reload/close; download to disk or optional connected-bucket autosave |
+| Received candidate, winner networks, descriptors and receipt | Browser page memory | Explicit discard, replacement, page reload/close; download to disk or optional connected-bucket autosave |
 | Optional HF identity / token | Browser page memory, separate from job/recipe storage | Sign out, expiry, or page reload/close; no app auth cookie or server session database |
 | Optional HF bucket OAuth grant | Separate explicit `openid profile write-repos` authorization; shared in memory with identity when granted together | Disconnect, observed expiry/denial, or page reload/close; no token in URL, localStorage, recipes or bundles |
 | One-use HF PKCE verifier/nonce | Tab-local sessionStorage for the sign-in redirect only | Five-minute acceptance limit; removed on return/error/fresh app load or tab close; never stores access tokens or files |
@@ -32,3 +32,5 @@ automatically share their library; explicit JSON export/import is the bridge.
 
 These are application lifecycle rules, not provider-wide erasure or a network
 sandbox. Hosted qualification must be repeated for each deployed build.
+
+Analysis is saved only with the user-selected local download or connected private bucket. The complete per-car measurements and immutable winner networks use the same temporary job lifecycle as the primary network. Frozen evaluation changes no network weights and does not start training when a bundle is restored.

UPSTREAM.json

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

WINNERS_AND_EVALUATION.md

@@ -0,0 +1,37 @@
+# Winners, measurements and frozen comparisons
+
+Training still uses the recipe you select. This app adds records you can inspect afterwards; it does not choose a curriculum or change your rewards automatically.
+
+## What a training result preserves
+
+- **Fitness winner:** the best car under your selected reward recipe in the final evaluated population. This is the usual primary network download.
+- **Fastest lap:** the car with the fastest completed forward lap observed during the run, even if it was not the final fitness winner.
+- **Clean laps:** the fastest qualifying car that completed the required number of forward laps without physical wall contact. The default is two clean laps.
+
+A single car can qualify for several categories. A category without a qualifying car is marked unavailable. Saving a winner preserves the exact policy evaluated for that result; later mutations do not replace its weights.
+
+Every evaluated car has a measurement row, including the reward metrics you did not select. The archive contains raw measurements, update counts, reward-channel values, within-population ranks, the selected fitness score, completed laps, distance, and contact counts. A reward-channel rank depends on the population it was measured against. It is not an absolute score you can compare across unrelated runs. Missing measurements remain missing.
+
+Saving a result to your connected private bucket also preserves the available winner networks and analysis. Names distinguish the run and winner category. Existing saves are not overwritten. You can also download the analysis for local use. Earlier bundle files remain readable; they cannot acquire measurements that were never recorded.
+
+## Recipe libraries in your bucket
+
+Recipe import and export offer both local JSON files and your connected private bucket. Bucket exports save the current browser library of named recipes and batches under a new dated entry. They include settings only; networks, tracks, run results and credentials are not part of a recipe library.
+
+Refresh saved recipes to list bucket entries and select the latest. Importing a selected library asks before replacing this browser's saved recipes and batches. It does not start training or automatically apply a different training strategy. Existing bucket exports are not overwritten. The same 32-KiB library limit applies to files and buckets.
+
+## Frozen evaluation
+
+Choose evaluation to drive a network without training it. The evaluator starts with a fresh car and keeps the uploaded network unchanged: no mutation, weight decay, crossover or reproduction. Evaluation does not create a new winner population.
+
+Select the winners you want to compare, choose the evaluation conditions, and start the comparison. Each distinct policy runs in sequence with its weights frozen. The evaluation may be longer than the original training run. Compare saved winners under one set of conditions: track, vehicle, run duration, controller frequency, collision elimination and idle elimination. Use the same engine build and backend for a direct comparison. Each policy retains its own identity. Different conditions are shown as incompatible rather than silently converted.
+
+Look at completed laps, clean-lap eligibility, contacts, distance and lap time together. A short evaluation that ends before the second lap cannot establish two-lap reliability. A fast lap with contacts is not a clean-lap result. Replica lap times remain simulator measurements; they do not establish an official Steam leaderboard result.
+
+## Data lifetime
+
+Primary network and analysis are one temporary server result. The browser checks both before acknowledging deletion. Bucket saving then uses the verified bytes held in the browser. If a bucket save fails, the local result remains available for retry or download. Closing the page can lose an unsaved local result.
+
+Analysis can be much larger than a network. Bounded size limits protect the service and browser. The app must report an oversized or incomplete result explicitly; it must not silently drop cars, generations or reward channels and call the archive complete.
+
+The bucket is user-owned storage. Application cleanup applies to temporary processing copies, not the files you have chosen to save in that bucket. Provider-wide retention is outside this app's guarantee. Recipes remain under your control; this feature does not choose or adapt them for you.

analysis_result.py

@@ -0,0 +1,153 @@
+"""Convert bounded native observations into portable, byte-bound analysis files.
+
+No selection is performed here: native snapshots were taken before turnover.
+"""
+import copy
+import gzip
+import hashlib
+import json
+import math
+import struct
+import uuid
+from pathlib import Path
+
+MAX_ANALYSIS_BYTES = 256 * 1024 * 1024
+METRIC_NAMES = ('total_score','total_speed','total_abs_steering','total_actual_distance',
+    'total_drifting_amount','total_momentum_change_frequency','total_throttle_change_frequency',
+    'total_braking_frequency','total_distance_from_wall','total_distance_from_center',
+    'network_novelty','collision_count','best_lap_performance','total_racing_line_efficiency')
+AVERAGE = set(METRIC_NAMES[:10])
+AVERAGE_ONLY = {'total_abs_steering','total_momentum_change_frequency','total_throttle_change_frequency',
+    'total_braking_frequency','total_distance_from_wall','total_distance_from_center'}
+CHANNELS = [{'metric':metric,'type':kind} for metric in METRIC_NAMES for kind in ('default','average')
+    if not (kind=='default' and metric in AVERAGE_ONLY) and not (kind=='average' and metric not in AVERAGE)]
+ROLES = ('fitness','fastest_lap','clean_laps')
+
+def encoded(value):
+    return json.dumps(value,allow_nan=False,separators=(',',':')).encode()
+
+def bounded_read(path,limit=MAX_ANALYSIS_BYTES):
+    path=Path(path)
+    if path.is_symlink() or not path.is_file() or path.stat().st_size>limit:
+        raise ValueError('Invalid or oversized native analysis file')
+    with path.open('rb') as stream:data=stream.read(limit+1)
+    if len(data)>limit:raise ValueError('Native analysis exceeds complete artifact limit')
+    return data
+
+def parsed(data):
+    return json.loads(data,parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite native analysis')))
+
+def parameter_hash(network):
+    params=[]
+    for matrix,bias in zip(network['weights'],network['biases']):
+        params.extend(value for row in matrix for value in row)
+        params.extend(bias)
+    return hashlib.sha256(b''.join(struct.pack('<d',value) for value in params)).hexdigest()
+
+def file_descriptor(name,data):
+    return {'name':name,'bytes':len(data),'sha256':hashlib.sha256(data).hexdigest()}
+
+def checked_row(row,generation,car):
+    if not isinstance(row,dict) or row.get('schema')!=1 or row.get('generation')!=generation or row.get('car')!=car:
+        raise ValueError('Missing or reordered native observations')
+    if row.get('candidate_id')!=f'g{generation:06}-c{car:06}':raise ValueError('Native candidate identity mismatch')
+    if set(row.get('raw_metrics',{}))!=set(METRIC_NAMES):raise ValueError('Incomplete native raw metrics')
+    channels=row.get('channels')
+    keys=('values','population_relative','unavailable_reasons')
+    if not isinstance(channels,dict) or set(channels)!=set(keys) or any(not isinstance(channels[k],list) or len(channels[k])!=18 for k in keys):
+        raise ValueError('Incomplete native channels')
+    for value,rank,reason in zip(*(channels[k] for k in keys)):
+        for number in (value,rank):
+            if number is not None and (type(number) not in (int,float) or not math.isfinite(number)):
+                raise ValueError('Invalid native measurement')
+        if value is None:
+            if rank is not None or not isinstance(reason,str) or not reason:raise ValueError('Missing channel fabricated')
+        elif rank is None or not 0<=rank<=1 or reason is not None:raise ValueError('Invalid native channel rank')
+    return row
+
+def assemble_analysis(out,template,primary,network_bytes,track_bytes,config,backend,validator):
+    native_dir=Path(out)/'analysis'
+    native=parsed(bounded_read(native_dir/'analysis.json',1024*1024))
+    if native.get('schema')!='ald.native-analysis' or native.get('version')!=1 or native.get('mode')!=config['mode']:
+        raise ValueError('Native analysis contract unavailable')
+    descriptors=bounded_read(native_dir/'descriptors.jsonl')
+    population=1 if config['mode']=='evaluate' else config['population']
+    generations=1 if config['mode']=='evaluate' else config['generations']
+    expected=population*generations
+    winner_rows=native.get('winners',{})
+    if set(winner_rows)!=set(ROLES):raise ValueError('Incomplete native winner categories')
+    selected_ids={r['candidate_id']:r for r in winner_rows.values() if r is not None}
+    seen_selected=set();count=0;evaluation_row=None
+    # Stream rows instead of retaining every decoded population in memory.
+    import io
+    for line in io.BytesIO(descriptors):
+        if not line.strip():raise ValueError('Empty native descriptor row')
+        count+=1
+        if count>expected:raise ValueError('Extra native observations')
+        row=checked_row(parsed(line),(count-1)//population+1,(count-1)%population)
+        if row['candidate_id'] in selected_ids:
+            if row!=selected_ids[row['candidate_id']]:raise ValueError('Winner observation not in descriptor stream')
+            seen_selected.add(row['candidate_id'])
+        if config['mode']=='evaluate':evaluation_row=row
+    if count!=expected or native.get('rows')!=count or set(selected_ids)!=seen_selected:
+        raise ValueError('Incomplete native analysis')
+    files={'descriptors.jsonl':descriptors}
+    conditions={'track_sha256':hashlib.sha256(track_bytes).hexdigest(),
+        'network_sha256':hashlib.sha256(network_bytes).hexdigest(),'vehicle_type':template['Type'],
+        'requested_ticks':config['ticks'],'control_hz':config['control_hz'],
+        'collision':config['collision'],'idle':config['idle'],'math_profile':'proton','clean_min_laps':config['clean_min_laps']}
+    winners={}
+    for role,row in winner_rows.items():
+        metadata={'status':'unavailable','reason':('frozen_evaluation_does_not_select_winners' if config['mode']=='evaluate'
+            else 'no_completed_lap' if role=='fastest_lap' else 'no_eligible_clean_laps'),
+            'candidate_id':None,'generation':None,'car':None,'selection_fitness':None,
+            'best_lap_seconds':None,'forward_laps':None,'physical_contacts':None,'collision_updates':None,
+            'total_actual_distance':None,'artifact':None}
+        if row is not None:
+            if config['mode']!='train':raise ValueError('Frozen evaluation selected a winner')
+            objective=row['objectives'];lap=objective['best_lap_seconds']
+            if role=='fitness' and row['generation']!=generations:raise ValueError('Fitness winner is not final population')
+            if role!='fitness' and (lap is None or lap<=0 or objective['forward_laps']<1):raise ValueError('Winner did not complete a lap')
+            if role=='clean_laps' and (objective['forward_laps']<config['clean_min_laps'] or objective['physical_contacts']!=0):
+                raise ValueError('Clean winner not eligible')
+            selected=parsed(bounded_read(native_dir/'winners'/f'{role}.json',1024*1024))
+            if selected.get('observation')!=row or parameter_hash(selected)!=row['weights_sha256']:
+                raise ValueError('Selected weights do not match observed controller')
+            game=copy.deepcopy(template)
+            game['NeuralNetwork']['Weights']=selected['weights'];game['NeuralNetwork']['Biases']=selected['biases']
+            if role=='fitness':data=primary
+            else:
+                game['Id']=str(uuid.uuid4());game['Name']='HF '+('fastest lap' if role=='fastest_lap' else 'clean laps')+' winner'
+                data=gzip.compress(encoded(game),mtime=0)
+            checked=validator(data)
+            observed={'weights':checked['NeuralNetwork']['Weights'],'biases':checked['NeuralNetwork']['Biases']}
+            if parameter_hash(observed)!=row['weights_sha256']:raise ValueError('Game export changed selected weights')
+            name=f'winners/{role}.evolution';files[name]=data
+            metadata.update(status='available',reason=None,candidate_id=row['candidate_id'],generation=row['generation'],car=row['car'],
+                selection_fitness=row['selection_fitness'],artifact=file_descriptor(name,data),**objective)
+            metadata.pop('active',None)
+        winners[role]=metadata
+    if config['mode']=='train' and winners['fitness']['status']!='available':raise ValueError('Missing fitness winner')
+    summary={'schema':'ald.run-analysis','version':1,'mode':config['mode'],'execution_backend':backend,
+        'conditions':conditions,'observations':{'generations':generations,'cars':count,'raw_metric_count':14,'reward_channel_count':18},
+        'winners':winners,'semantics':{
+            'fitness':'Final evaluated population leader; rank fitness is relative to that population',
+            'fastest_lap':'Run-global positive completed lap; earliest generation/car breaks ties',
+            'clean_laps':'Run-global zero physical contacts and required forward laps; fastest eligible lap; earliest generation/car breaks ties',
+            'channels':'Unsigned ranks within the observed population; averages divide by 0.1 * stats updates; null is unavailable',
+            'collision_count':'Reward collision updates differ from physical contacts',
+            'training':'Training reuses physical vehicle state between generations; winner observations need not equal a fresh replay',
+            'evaluation':'Fresh cars, exact fixed weights, no reproduction/mutation/decay; novelty is relative to the evaluation population'}}
+    analysis={**summary,'metric_names':list(METRIC_NAMES),'reward_channels':CHANNELS,'settings':config,
+        'descriptors':{**file_descriptor('descriptors.jsonl',descriptors),'rows':count}}
+    files['analysis.json']=encoded(analysis)
+    evaluation=None
+    if config['mode']=='evaluate':
+        original={'weights':template['NeuralNetwork']['Weights'],'biases':template['NeuralNetwork']['Biases']}
+        if evaluation_row['weights_sha256']!=parameter_hash(original) or primary!=network_bytes or evaluation_row['selection_fitness'] is not None:
+            raise ValueError('Frozen evaluation altered input policy')
+        evaluation={'schema':'ald.frozen-evaluation','version':1,'conditions':conditions,
+            'input_sha256':hashlib.sha256(network_bytes).hexdigest(),'weights_unchanged':True,'measurements':evaluation_row}
+        files['evaluation.json']=encoded(evaluation)
+    if sum(map(len,files.values()))>MAX_ANALYSIS_BYTES:raise ValueError('Complete analysis exceeds 256 MiB; no truncation')
+    return files,summary,evaluation

app.py

@@ -17,14 +17,14 @@ from fastapi.responses import FileResponse,JSONResponse
 from app_release import ROOT,cpu_worker,verify_package
 from gpu_tickets import InputTickets
 from server import create_app
-from delivery import CapacityExceeded
+from delivery import CapacityExceeded, publish_worker_result
 from worker import run_native,track_input,network_input
 from training_config import validate_config
 from build_info import build_identity
 from hf_identity import visitor_identity
 
-def build_app(cuda_call):
-    base=create_app(worker=cpu_worker)
+def build_app(cuda_call,require_analysis=False):
+    base=create_app(worker=cpu_worker,require_analysis=require_analysis)
     tickets=InputTickets()
     admission=threading.BoundedSemaphore(1)
 
@@ -93,7 +93,9 @@ def build_app(cuda_call):
             track,network,automatic,*config=tickets.take(ticket)
             try:
                 payload,report=cuda_call(track,network,*config)
-                return {**base.state.results.publish(payload,automatic),'backend':'gpu','report':report}
+                published,public_report=publish_worker_result(
+                    base.state.results,payload,report,automatic,require_analysis=require_analysis)
+                return {**published,'backend':'gpu','report':public_report}
             except CapacityExceeded:
                 raise ValueError('Result capacity reached; no result was published.') from None
             except Exception:
@@ -125,7 +127,7 @@ def main():
             importer=ROOT/'bin/extract_saved_track',scene_template=ROOT/'assets/formula_template.json',
             gpu_library=ROOT/'bin/libaltd_gpu.so',with_report=True,config=config)
 
-    build_app(cuda).launch(server_name='0.0.0.0',server_port=7860,run_history=False,
+    build_app(cuda,require_analysis=True).launch(server_name='0.0.0.0',server_port=7860,run_history=False,
         enable_monitoring=False,show_error=False)
 
 if __name__=='__main__':main()

bin/altd-sim

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

bucket_storage.py

@@ -15,17 +15,22 @@ import sys
 import tempfile
 import uuid
 
-from portable_bundle import BundleError, MAX_BUNDLE, MAX_NETWORK, load_bundle
+from portable_bundle import (
+    BundleError, MAX_BUNDLE, MAX_NETWORK, MAX_ANALYSIS_ARCHIVE,
+    MAX_ANALYSIS_FILE_BYTES, load_bundle,
+)
 from worker import network_input
 
 HF_ENDPOINT = "https://huggingface.co"
 MAX_REQUEST = 2 * MAX_BUNDLE + 64 * 1024
+MAX_RECIPE_LIBRARY = 32 * 1024
 MAX_CHILD_INPUT = 4 * ((MAX_BUNDLE + 2) // 3) + 64 * 1024
 MAX_CHILD_OUTPUT = 128 * 1024
 CHILD_TIMEOUT_SECONDS = 55
 MAX_LIST_SCAN = 10_000
 MAX_LIST_RESULTS = 50
 LEGACY_APP_KEY = re.compile(r"^ald-exports/([0-9a-f]{32}|[0-9a-f]{64})/bundle\.json$")
+RECIPE_APP_KEY = re.compile(r"^ald-recipes/(?P<timestamp>[0-9]{8}T[0-9]{6}Z)-(?P<uuid>[0-9a-f]{32})/library\.json$")
 AUTOSAVE_APP_KEY = re.compile(
     r"^ald-exports/(?P<timestamp>[0-9]{8}T[0-9]{6}Z)-"
     r"(?P<track>[a-z0-9][a-z0-9-]{0,63})-"
@@ -34,7 +39,7 @@ AUTOSAVE_APP_KEY = re.compile(
     r"lap(?P<lap>none|[0-9]{1,16}ms)-(?P<uuid>[0-9a-f]{32})/bundle\.json$"
 )
 VEHICLE_NAMES = ("Formula", "Rally", "Snowmobile", "Truck")
-MAX_SIDECAR_TOTAL = 1024 * 1024
+MAX_SIDECAR_TOTAL = 320 * 1024 * 1024
 BUCKET_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}/[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$")
 
 
@@ -54,6 +59,149 @@ def valid_bundle_key(value: object) -> bool:
     return isinstance(value, str) and bool(LEGACY_APP_KEY.fullmatch(value) or AUTOSAVE_APP_KEY.fullmatch(value))
 
 
+def valid_recipe_key(value: object) -> bool:
+    if not isinstance(value, str):
+        return False
+    match = RECIPE_APP_KEY.fullmatch(value)
+    if match is None:
+        return False
+    try:
+        datetime.strptime(match.group("timestamp"), "%Y%m%dT%H%M%SZ")
+    except ValueError:
+        return False
+    return True
+
+
+RECIPE_DEFAULT_SETTINGS = {
+    "population": 4, "generations": 1, "ticks": 60, "mutation": 0.01,
+    "seed": 42, "mutation_end": 0.01, "schedule": "fixed", "selection": "best",
+    "parents": 1, "elite": 1, "crossover": "none", "decay": 0,
+    "adaptive_mutation": False, "control_hz": 30, "workers": 1,
+    "collision": False, "idle": False,
+    "rewards": [{"metric": "total_score", "type": "default", "weight": 100}],
+}
+RECIPE_METRICS = {
+    "total_score", "total_speed", "total_abs_steering", "total_actual_distance",
+    "total_drifting_amount", "total_momentum_change_frequency", "total_throttle_change_frequency",
+    "total_braking_frequency", "total_distance_from_wall", "total_distance_from_center",
+    "network_novelty", "collision_count", "best_lap_performance", "total_racing_line_efficiency",
+}
+
+
+def validate_recipe_library(raw: bytes) -> dict:
+    """Validate the existing browser RecipeLibrary v1 format, without storing other app data."""
+    if not isinstance(raw, bytes) or len(raw) > MAX_RECIPE_LIBRARY:
+        raise ValueError("Invalid recipe library")
+
+    def unique_object(pairs):
+        value = {}
+        for key, item in pairs:
+            if key in value:
+                raise ValueError("Duplicate recipe field")
+            value[key] = item
+        return value
+
+    try:
+        book = json.loads(raw.decode("utf-8"), object_pairs_hook=unique_object,
+                          parse_constant=lambda _value: (_ for _ in ()).throw(ValueError("Invalid number")))
+    except Exception:
+        raise ValueError("Invalid recipe library") from None
+    if not isinstance(book, dict) or set(book) not in ({"version", "recipes"}, {"version", "recipes", "batches"}):
+        raise ValueError("Invalid recipe library")
+    if type(book.get("version")) is not int or book["version"] != 1:
+        raise ValueError("Invalid recipe library")
+    recipes = book.get("recipes")
+    if not isinstance(recipes, list) or len(recipes) > 10:
+        raise ValueError("Invalid recipe library")
+    seen = set()
+    for recipe in recipes:
+        if not isinstance(recipe, dict) or set(recipe) != {"slot", "name", "settings"}:
+            raise ValueError("Invalid recipe library")
+        slot, name = recipe["slot"], recipe["name"]
+        if not isinstance(slot, str) or not re.fullmatch(r"[A-J]", slot) or slot in seen:
+            raise ValueError("Invalid recipe library")
+        if not isinstance(name, str) or not name.strip() or len(name) > 80:
+            raise ValueError("Invalid recipe library")
+        seen.add(slot)
+        settings = recipe["settings"]
+        if not isinstance(settings, dict) or set(settings) - set(RECIPE_DEFAULT_SETTINGS):
+            raise ValueError("Invalid recipe library")
+        clean = {**RECIPE_DEFAULT_SETTINGS, **settings}
+        numeric = {
+            "population": (1, 128, True), "generations": (1, 1000, True),
+            "ticks": (1, 18000, True), "mutation": (0, 4.2, False),
+            "mutation_end": (0, 4.2, False), "seed": (0, 2147483647, True),
+            "parents": (1, 128, True), "elite": (0, 128, True),
+            "decay": (0, 1, False), "workers": (1, 4, True),
+        }
+        for key, (low, high, integer) in numeric.items():
+            value = clean[key]
+            if (type(value) not in (int, float) or not low <= value <= high
+                    or (integer and not float(value).is_integer())):
+                raise ValueError("Invalid recipe library")
+        enums = {"schedule": {"fixed", "linear", "geometric"},
+                 "selection": {"best", "tournament", "roulette"},
+                 "crossover": {"none", "single_point", "uniform"},
+                 "control_hz": {60, 30, 15}}
+        for key, choices in enums.items():
+            if type(clean[key]) not in (str, int, float) or clean[key] not in choices:
+                raise ValueError("Invalid recipe library")
+        for key in ("adaptive_mutation", "collision", "idle"):
+            if type(clean[key]) is not bool:
+                raise ValueError("Invalid recipe library")
+        if clean["parents"] > clean["population"] or clean["elite"] > clean["population"] or clean["mutation"] <= 0:
+            raise ValueError("Invalid recipe library")
+        if clean["schedule"] != "fixed" and clean["mutation_end"] <= 0:
+            raise ValueError("Invalid recipe library")
+        rewards = clean["rewards"]
+        if not isinstance(rewards, list) or not 1 <= len(rewards) <= 5:
+            raise ValueError("Invalid recipe library")
+        reward_metrics = set()
+        for reward in rewards:
+            if not isinstance(reward, dict) or set(reward) != {"metric", "type", "weight"}:
+                raise ValueError("Invalid recipe library")
+            metric, reward_type, weight = reward["metric"], reward["type"], reward["weight"]
+            if (not isinstance(metric, str) or metric not in RECIPE_METRICS
+                    or not isinstance(reward_type, str) or reward_type not in {"default", "average"}
+                    or metric in reward_metrics or type(weight) not in (int, float)
+                    or not -100 <= weight <= 100 or not float(weight).is_integer()):
+                raise ValueError("Invalid recipe library")
+            reward_metrics.add(metric)
+        if not any(reward["weight"] for reward in rewards):
+            raise ValueError("Invalid recipe library")
+
+    batches = book.get("batches", [])
+    if not isinstance(batches, list) or len(batches) > 10:
+        raise ValueError("Invalid recipe library")
+    batch_slots = set()
+    for batch in batches:
+        if not isinstance(batch, dict) or set(batch) != {"slot", "name", "carry", "runs"}:
+            raise ValueError("Invalid recipe library")
+        slot, name, runs = batch["slot"], batch["name"], batch["runs"]
+        if (not isinstance(slot, str) or not re.fullmatch(r"[A-J]", slot) or slot in batch_slots
+                or not isinstance(name, str) or not name.strip() or len(name) > 80
+                or type(batch["carry"]) is not bool or not isinstance(runs, list) or not 1 <= len(runs) <= 100
+                or any(not isinstance(run, str) or run not in seen for run in runs)):
+            raise ValueError("Invalid recipe library")
+        batch_slots.add(slot)
+    return book
+
+
+def _recipe_list_metadata(key: str, uploaded: object) -> tuple[str, str | None]:
+    match = RECIPE_APP_KEY.fullmatch(key)
+    if match is None:
+        raise BucketStorageError("invalid_request")
+    try:
+        path_when = datetime.strptime(match.group("timestamp"), "%Y%m%dT%H%M%SZ").replace(tzinfo=timezone.utc)
+    except ValueError:
+        path_when = None
+    when = _valid_utc_datetime(uploaded) or path_when
+    if when is None:
+        return f"Saved recipe library · {match.group('uuid')[:8]}", None
+    created_at = when.isoformat(timespec="microseconds").replace("+00:00", "Z")
+    return f"Recipe library · {when.strftime('%Y-%m-%d %H:%M UTC')} · {match.group('uuid')[:8]}", created_at
+
+
 def _autosave_prefix(bundle: dict, files: dict[str, bytes], now: datetime | None = None) -> tuple[str, str, str]:
     artifacts = bundle["artifacts"]
     receipt = artifacts.get("run_receipt")
@@ -86,6 +234,17 @@ def _readable_track(track_id: str, track: dict | None) -> str:
     return "custom-track"
 
 
+def winner_sidecar_filename(track_slug: str, vehicle: str, timestamp: str, unique: str, role: str) -> str:
+    role_label = {"fitness": "fitness-winner", "fastest_lap": "fastest-lap-winner",
+                  "clean_laps": "clean-laps-winner"}.get(role)
+    if (not role_label or not re.fullmatch(r"[a-z0-9][a-z0-9-]{0,63}", track_slug)
+            or vehicle not in {"formula", "rally", "snowmobile", "truck"}
+            or not re.fullmatch(r"[0-9]{8}T[0-9]{6}Z", timestamp)
+            or not re.fullmatch(r"[0-9a-f]{8}", unique)):
+        raise BucketStorageError("invalid_bundle")
+    return f"{track_slug}-{vehicle}-{timestamp}-{unique}-{role_label}.evolution"
+
+
 def _track_path_slug(track: dict | None) -> str:
     if isinstance(track, dict) and track.get("source") == "builtin":
         display_name = track.get("display_name")
@@ -98,7 +257,7 @@ def _track_path_slug(track: dict | None) -> str:
             fragment = re.sub(r"[^A-Za-z0-9]+", "-", track_id).strip("-").lower()[:48].strip("-")
             if fragment:
                 return "track-" + fragment
-    return "custom"
+    return "custom-track"
 
 
 def _render_history_csv(report: dict) -> bytes:
@@ -116,11 +275,13 @@ def _render_report(bundle: dict) -> bytes:
     receipt = artifacts["run_receipt"]
     report = receipt["report"]
     track = artifacts.get("selected_track")
+    summary = report.get("analysis_summary")
+    evaluation = isinstance(summary, dict) and summary.get("mode") == "evaluate"
     track_label = track.get("display_name", "Built-in track") if isinstance(track, dict) and track.get("source") == "builtin" else "Custom or uploaded track"
     lap = report["best_lap_seconds"]
     lap_label = "No completed lap" if lap is None else f"{lap:.3f} s"
     lines = [
-        "# ALD training run",
+        "# ALD frozen evaluation" if evaluation else "# ALD training run",
         "",
         f"- Track: {track_label}",
         f"- Vehicle: {report['vehicle_name']}",
@@ -131,7 +292,6 @@ def _render_report(bundle: dict) -> bytes:
         f"- Final-generation best score: {report['best_score']}",
         f"- Final-generation mean score: {report['mean_score']}",
         f"- Best completed lap observed during this run: {lap_label}",
-        "- The best completed lap may belong to a different car than the exported candidate.",
         f"- Lapped cars in the final generation: {report['lapped_cars']}",
         f"- Simulated ticks: {report['simulated_ticks']} of {report['requested_ticks']} requested per car",
         f"- Elapsed seconds: {report['elapsed_seconds']:.3f}",
@@ -142,6 +302,20 @@ def _render_report(bundle: dict) -> bytes:
     ]
     for key in sorted(report["settings"]):
         lines.append(f"- {key}: `{json.dumps(report['settings'][key], ensure_ascii=True, allow_nan=False, separators=(',', ':'))}`")
+    if isinstance(summary, dict):
+        lines.extend(["", "## Candidate analysis", "", f"- Mode: {summary['mode']}"])
+        if evaluation:
+            lines.append("- This is a frozen evaluation; the input network bytes and weights were preserved.")
+        else:
+            for role in ("fitness", "fastest_lap", "clean_laps"):
+                winner = summary["winners"][role]
+                if winner["status"] == "available":
+                    lines.append(f"- {role.replace('_', ' ').title()}: generation {winner['generation']}, car {winner['car']}, candidate `{winner['candidate_id']}`")
+                else:
+                    lines.append(f"- {role.replace('_', ' ').title()}: unavailable ({winner['reason']})")
+            lines.append("- A run-wide lap winner may be a different car from the exported fitness candidate.")
+    elif not evaluation:
+        lines.append("- The best completed lap may belong to a different car than the exported candidate.")
     return ("\n".join(lines) + "\n").encode("utf-8")
 
 
@@ -156,10 +330,22 @@ def _save_files(bundle_bytes: bytes, bundle: dict, files: dict[str, bytes], *, n
         vehicle = VEHICLE_NAMES[network_input(files["selected_network.evolution"])["Type"]].lower()
     uploads = {"bundle.json": bundle_bytes}
     network_suffix = prefix.rsplit("-", 1)[-1][:8]
-    uploads[f"{_readable_track(track, artifacts.get('selected_track'))}-{vehicle}-{timestamp}-{network_suffix}.evolution"] = files["selected_network.evolution"]
+    readable_track = _readable_track(track, artifacts.get('selected_track'))
+    uploads[f"{readable_track}-{vehicle}-{timestamp}-{network_suffix}.evolution"] = files["selected_network.evolution"]
     if receipt is not None:
         uploads["report.md"] = _render_report(bundle)
         uploads["generation-history.csv"] = _render_history_csv(receipt["report"])
+    if bundle.get("version") == 2:
+        if "analysis_archive.gz" not in files:
+            raise BucketStorageError("invalid_bundle")
+        uploads["analysis-archive.gz"] = files["analysis_archive.gz"]
+        for name, content in files.items():
+            if name.startswith("analysis/"):
+                uploads[name] = content
+        for role in ("fitness", "fastest_lap", "clean_laps"):
+            name = f"analysis/winners/{role}.evolution"
+            if name in files:
+                uploads[winner_sidecar_filename(readable_track, vehicle, timestamp, network_suffix, role)] = files[name]
     if sum(map(len, uploads.values())) > MAX_BUNDLE + MAX_NETWORK + MAX_SIDECAR_TOTAL:
         raise BucketStorageError("invalid_bundle")
     return prefix, uploads
@@ -231,7 +417,7 @@ def _child_environment(cache_root: Path) -> dict[str, str]:
 
 def run_bucket_operation(operation: str, token: str, bucket_id: str, **args):
     """Run one HF operation in an isolated process with a temporary Xet cache."""
-    if operation not in {"connect", "list", "save", "restore"}:
+    if operation not in {"connect", "list", "save", "restore", "recipes_list", "recipes_save", "recipes_restore"}:
         raise BucketStorageError("invalid_request")
     if not isinstance(token, str) or not token or len(token) > 4096 or any(ch.isspace() or ord(ch) < 33 for ch in token):
         raise BucketStorageError("unauthorized")
@@ -266,24 +452,37 @@ def run_bucket_operation(operation: str, token: str, bucket_id: str, **args):
                 if category in {"unauthorized", "forbidden", "not_found", "invalid_request", "storage_unavailable"}:
                     raise BucketStorageError(category)
                 raise BucketStorageError("storage_unavailable")
-            if operation in {"save", "restore"}:
-                expected_name = "readback.json" if operation == "save" else "restore.json"
+            if operation in {"save", "restore", "recipes_save", "recipes_restore"}:
+                is_recipe = operation.startswith("recipes_")
+                is_save = operation in {"save", "recipes_save"}
+                expected_name = "recipe-readback.json" if operation == "recipes_save" else (
+                    "recipe-restore.json" if operation == "recipes_restore" else (
+                        "readback.json" if is_save else "restore.json"))
                 file_path = temp / expected_name
                 if not file_path.is_file() or file_path.is_symlink():
                     raise BucketStorageError("storage_unavailable")
-                if file_path.stat().st_size > MAX_BUNDLE:
+                max_bytes = MAX_RECIPE_LIBRARY if is_recipe else MAX_BUNDLE
+                if file_path.stat().st_size > max_bytes:
                     raise BucketStorageError("invalid_request")
                 content = file_path.read_bytes()
-                if operation == "save":
-                    if hashlib.sha256(content).hexdigest() != result.get("sha256"):
+                if is_save:
+                    if (hashlib.sha256(content).hexdigest() != result.get("sha256")
+                            or len(content) != result.get("bytes")):
                         raise BucketStorageError("storage_unavailable")
                     result["verified_bytes"] = content
                 else:
-                    try:
-                        load_bundle(content)
-                    except BundleError:
-                        raise BucketStorageError("invalid_bundle") from None
-                    result["bundle_bytes"] = content
+                    if is_recipe:
+                        try:
+                            validate_recipe_library(content)
+                        except Exception:
+                            raise BucketStorageError("invalid_request") from None
+                        result["recipe_bytes"] = content
+                    else:
+                        try:
+                            load_bundle(content)
+                        except BundleError:
+                            raise BucketStorageError("invalid_bundle") from None
+                        result["bundle_bytes"] = content
             return result
     except subprocess.TimeoutExpired:
         raise BucketStorageError("timeout") from None
@@ -311,14 +510,14 @@ def _verify_bucket(api, token: str, bucket_id: str):
     return username
 
 
-def _download_descriptor(api, token: str, bucket_id: str, key: str, destination: Path):
+def _download_descriptor(api, token: str, bucket_id: str, key: str, destination: Path, *, max_bytes: int = MAX_BUNDLE):
     from huggingface_hub._buckets import BucketFile
 
     metadata = api.get_bucket_file_metadata(bucket_id, key, token=token)
     size = getattr(metadata, "size", None)
     xet_data = getattr(metadata, "xet_file_data", None)
     xet_hash = getattr(xet_data, "file_hash", None)
-    if type(size) is not int or size < 0 or size > MAX_BUNDLE or not isinstance(xet_hash, str) or not xet_hash:
+    if type(size) is not int or size < 0 or size > max_bytes or not isinstance(xet_hash, str) or not xet_hash:
         raise BucketStorageError("invalid_request")
     descriptor = BucketFile(
         type="file",
@@ -349,6 +548,66 @@ def _perform_operation(request: dict, api, temp: Path) -> dict:
     username = _verify_bucket(api, token, bucket_id)
     if operation == "connect":
         return {"status": "connected", "bucket_id": bucket_id, "username": username, "private": True}
+    if operation == "recipes_list":
+        items = []
+        scan_incomplete = False
+        for index, item in enumerate(api.list_bucket_tree(bucket_id, prefix="ald-recipes", recursive=True, token=token)):
+            if index >= MAX_LIST_SCAN:
+                scan_incomplete = True
+                break
+            key = getattr(item, "path", None)
+            size = getattr(item, "size", None)
+            if valid_recipe_key(key) and type(size) is int and 0 <= size <= MAX_RECIPE_LIBRARY:
+                uploaded = getattr(item, "uploaded_at", None) or getattr(item, "mtime", None)
+                label, created_at = _recipe_list_metadata(key, uploaded)
+                items.append({"key": key, "bytes": size, "label": label, "created_at": created_at})
+        items.sort(key=lambda item: item["created_at"] or "", reverse=True)
+        truncated = len(items) > MAX_LIST_RESULTS
+        return {"items": items[:MAX_LIST_RESULTS], "truncated": truncated,
+                "scan_incomplete": scan_incomplete}
+    if operation == "recipes_save":
+        encoded = request.get("library_base64")
+        if not isinstance(encoded, str) or len(encoded) > 4 * ((MAX_RECIPE_LIBRARY + 2) // 3):
+            raise BucketStorageError("invalid_request")
+        try:
+            library = base64.b64decode(encoded, validate=True)
+            validate_recipe_library(library)
+        except Exception:
+            raise BucketStorageError("invalid_request") from None
+        digest = hashlib.sha256(library).hexdigest()
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        prefix = f"ald-recipes/{timestamp}-{uuid.uuid4().hex}"
+        source = temp / "recipe-upload"
+        source.mkdir(mode=0o700)
+        (source / "library.json").write_bytes(library)
+        try:
+            api.sync_bucket(str(source), f"hf://buckets/{bucket_id}/{prefix}",
+                            delete=False, ignore_existing=True, quiet=True, token=token)
+        except Exception:
+            raise BucketStorageError("storage_unavailable") from None
+        key = f"{prefix}/library.json"
+        readback = temp / "recipe-readback.json"
+        size, _ = _download_descriptor(api, token, bucket_id, key, readback,
+                                       max_bytes=MAX_RECIPE_LIBRARY)
+        content = readback.read_bytes()
+        if size != len(library) or content != library or hashlib.sha256(content).hexdigest() != digest:
+            raise BucketStorageError("storage_unavailable")
+        return {"status": "saved_verified", "bucket_id": bucket_id, "key": key,
+                "bytes": len(library), "sha256": digest}
+    if operation == "recipes_restore":
+        key = request.get("key")
+        if not valid_recipe_key(key):
+            raise BucketStorageError("invalid_request")
+        restore = temp / "recipe-restore.json"
+        size, _ = _download_descriptor(api, token, bucket_id, key, restore,
+                                       max_bytes=MAX_RECIPE_LIBRARY)
+        content = restore.read_bytes()
+        try:
+            validate_recipe_library(content)
+        except Exception:
+            raise BucketStorageError("invalid_request") from None
+        return {"status": "restored", "key": key, "bytes": size,
+                "sha256": hashlib.sha256(content).hexdigest()}
     if operation == "list":
         items = []
         scan_incomplete = False
@@ -384,7 +643,12 @@ def _perform_operation(request: dict, api, temp: Path) -> dict:
         source = temp / "upload"
         source.mkdir(mode=0o700)
         for filename, content in uploads.items():
-            (source / filename).write_bytes(content)
+            if (not isinstance(filename, str) or filename.startswith("/")
+                    or any(part in {"", ".", ".."} for part in filename.split("/"))):
+                raise BucketStorageError("invalid_bundle")
+            path = source.joinpath(*filename.split("/"))
+            path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+            path.write_bytes(content)
         try:
             api.sync_bucket(
                 str(source), f"hf://buckets/{bucket_id}/{prefix}",
@@ -396,7 +660,7 @@ def _perform_operation(request: dict, api, temp: Path) -> dict:
         for index, (filename, expected) in enumerate(uploads.items()):
             remote_path = f"{prefix}/{filename}"
             readback = temp / f"readback-{index}.bin"
-            size, _ = _download_descriptor(api, token, bucket_id, remote_path, readback)
+            size, _ = _download_descriptor(api, token, bucket_id, remote_path, readback, max_bytes=len(expected))
             content = readback.read_bytes()
             expected_sha = hashlib.sha256(expected).hexdigest()
             if size != len(expected) or hashlib.sha256(content).hexdigest() != expected_sha:
@@ -429,7 +693,8 @@ def _child_main() -> int:
         return 2
     try:
         request = json.loads(raw.decode("utf-8"))
-        if not isinstance(request, dict) or request.get("operation") not in {"connect", "list", "save", "restore"}:
+        if not isinstance(request, dict) or request.get("operation") not in {
+                "connect", "list", "save", "restore", "recipes_list", "recipes_save", "recipes_restore"}:
             raise BucketStorageError("invalid_request")
         operation = request["operation"]
         token = request.get("token")

build_info.py

@@ -1,4 +1,4 @@
-"""Content-addressed package identity; no environment or credentials in reports."""
+"""Content-addressed package identity with explicit native patch provenance."""
 import hashlib
 import json
 from pathlib import Path
@@ -6,15 +6,19 @@ from pathlib import Path
 ROOT = Path(__file__).resolve().parent
 
 def build_identity():
-    manifest = json.loads((ROOT / 'RELEASE_MANIFEST.json').read_text())
-    upstream = json.loads((ROOT / 'UPSTREAM.json').read_text())
-    members = json.dumps(manifest['files'], sort_keys=True, separators=(',', ':')).encode()
+    manifest = json.loads((ROOT / "RELEASE_MANIFEST.json").read_text())
+    upstream = json.loads((ROOT / "UPSTREAM.json").read_text())
+    members = json.dumps(manifest["files"], sort_keys=True, separators=(",", ":")).encode()
+    native = upstream["native_build"]
     return {
-        'schema_version': 1,
-        'build_id': 'ald-beta-' + hashlib.sha256(members).hexdigest(),
-        'source_repository': upstream['repository'],
-        'simulator_source_revision': upstream['commit'],
-        'math_profile': upstream['math_profile'],
-        'package_role': upstream['role'],
-        'binary_sha256': {name: digest for name, digest in manifest['files'].items() if name.startswith('bin/')},
+        "schema_version": 1,
+        "build_id": "ald-winners-" + hashlib.sha256(members).hexdigest(),
+        "source_repository": upstream["repository"],
+        "simulator_source_revision": upstream["commit"],
+        "math_profile": upstream["math_profile"],
+        "package_role": 'gpu',
+        "binary_sha256": {name: digest for name, digest in manifest["files"].items() if name.startswith("bin/")},
+        "native_source_revision": native["source_revision"],
+        "native_patch_sha256": native["patch_sha256"],
+        "native_build_receipt_sha256": native["build_receipt_sha256"],
     }

client.js

@@ -3,6 +3,11 @@ const $ = id => document.getElementById(id);
 let job = null;
 let busy = false;
 let localResult = null;
+let localAnalysis = null;
+let pairedAnalysisPending = false;
+let selectedWinner = null;
+let comparisonRows = [];
+let comparisonPlan = null;
 let capabilitiesReady = false;
 let gpuTransport = null;
 let gpuAvailable = false;
@@ -23,6 +28,8 @@ let bucketId = null;
 let bucketUsername = null;
 let bucketItems = [];
 let bucketSelectedKey = null;
+let bucketRecipeItems = [];
+let bucketRecipeSelectedKey = null;
 let bucketOperation = false;
 let bucketOperationId = 0;
 let bucketEpoch = 0;
@@ -50,30 +57,53 @@ function buttons() {
   $('download').disabled = busy || !job;
   $('erase').disabled = busy || !job;
   const autosaving=!!bucketToken&&!!$('bucket_autosave')?.checked;
-  $('keepServer').disabled = busy || !!job || autosaving;
+  $('keepServer').disabled = busy || !!job || autosaving || !!comparisonPlan;
   $('saveLocal').disabled = busy || !localResult;
   $('forgetLocal').disabled = busy || !localResult;
   $('track').disabled=unavailable;
   $('network').disabled=unavailable;
-  if($('batch_start'))$('batch_start').disabled=unavailable || !capabilitiesReady || ($('backend').value==='gpu'&&!gpuAvailable);
+  if($('batch_start'))$('batch_start').disabled=unavailable || !capabilitiesReady || $('run_mode')?.value==='evaluate' || ($('backend').value==='gpu'&&!gpuAvailable);
   if($('batch_stop'))$('batch_stop').disabled=!batchActive || batchStopRequested;
-  if($('run_export'))$('run_export').disabled=busy || !runReceipt;
-  const report=cleanRunReceipt(runReceipt)||cleanRunReceipt(portableReceipt);
+  if($('run_export'))$('run_export').disabled=busy || !runReceipt || pairedAnalysisPending;
+  const report=pairedAnalysisPending?null:(cleanRunReceipt(runReceipt)||cleanRunReceipt(portableReceipt));
   if($('player_report_download'))$('player_report_download').disabled=busy||!report;
   if($('history_csv_download'))$('history_csv_download').disabled=busy||!report?.report?.history?.length;
   if($('batch_export'))$('batch_export').disabled=busy || !batchReceipt;
-  if($('bundle_export'))$('bundle_export').disabled=unavailable;
+  if($('run_mode'))$('run_mode').disabled=unavailable;
+  if($('clean_min_laps'))$('clean_min_laps').disabled=unavailable;
+  if($('analysis_download'))$('analysis_download').disabled=busy||!localAnalysis;
+  if($('descriptor_show'))$('descriptor_show').disabled=busy||!localAnalysis||localAnalysis.mode!=='train';
+  if($('compare_winners'))$('compare_winners').disabled=busy||!localAnalysis||!selectedWinnerRoles().length;
+  if($('compare_add'))$('compare_add').disabled=busy||!localAnalysis||localAnalysis.mode!=='evaluate';
+  if($('bundle_export'))$('bundle_export').disabled=unavailable||pairedAnalysisPending;
   if($('bundle_import'))$('bundle_import').disabled=unavailable;
   const storageToken=window.HFAuth?.getStorageToken?.()??null;
   if($('bucket_connect'))$('bucket_connect').disabled=unavailable||!storageToken||!!bucketToken;
   if($('bucket_id'))$('bucket_id').disabled=unavailable||!storageToken||!!bucketToken;
   if($('bucket_disconnect'))$('bucket_disconnect').disabled=unavailable||!bucketToken;
-  if($('bucket_save'))$('bucket_save').disabled=unavailable||!bucketToken||(!networkSource()&&!localResult);
+  if($('bucket_save'))$('bucket_save').disabled=unavailable||!bucketToken||(!networkSource()&&!localResult)||pairedAnalysisPending;
   if($('bucket_refresh'))$('bucket_refresh').disabled=unavailable||!bucketToken;
   if($('bucket_restore'))$('bucket_restore').disabled=unavailable||!bucketToken||!$('bucket_items')?.value;
   if($('bucket_items'))$('bucket_items').disabled=unavailable||!bucketToken;
+  if($('bucket_recipe_save'))$('bucket_recipe_save').disabled=unavailable||!bucketToken;
+  if($('bucket_recipe_refresh'))$('bucket_recipe_refresh').disabled=unavailable||!bucketToken;
+  if($('bucket_recipe_items'))$('bucket_recipe_items').disabled=unavailable||!bucketToken;
+  if($('bucket_recipe_import'))$('bucket_recipe_import').disabled=unavailable||!bucketToken||!$('bucket_recipe_items')?.value;
   if($('bucket_autosave'))$('bucket_autosave').disabled=unavailable||!bucketToken;
+  syncRunModeUI(unavailable);
 }
+const trainingOnlyControls=['population','generations','mutation','mutation_end','schedule','adaptive_mutation','selection','parents','elite','crossover','decay','preset','reward_preset','add','rewards'];
+function syncRunModeUI(unavailable=busy||!!job||bundleRestoring||bucketOperation){
+  const evaluation=$('run_mode')?.value==='evaluate';
+  for(const id of trainingOnlyControls){const node=$(id);if(node)node.disabled=unavailable||evaluation;}
+  if($('native_settings'))$('native_settings').hidden=evaluation;
+  if($('reward_settings'))$('reward_settings').hidden=evaluation;
+  if($('run'))$('run').textContent=evaluation?'Evaluate policy (weights frozen)':'Run training';
+  if($('run_mode_help'))$('run_mode_help').textContent=evaluation
+    ?'Frozen evaluation uses the selected policy unchanged in a fresh car. Mutation, decay, crossover, reproduction and winner selection are disabled.'
+    :'Training uses your selected recipe and records winner policies and per-car measurements.';
+}
+if($('run_mode'))$('run_mode').addEventListener('change',()=>{syncRunModeUI();buttons();});
 function renderBucketConnection(){
   const connected=!!bucketToken&&!!bucketId;
   const authorized=!!window.HFAuth?.getStorageToken?.();
@@ -89,11 +119,20 @@ function renderBucketConnection(){
     select.replaceChildren(...options);
     if(options.length)select.value=bucketSelectedKey&&bucketItems.some(item=>item.key===bucketSelectedKey)?bucketSelectedKey:'';
   }
+  const recipeSelect=$('bucket_recipe_items');
+  if(recipeSelect){
+    const options=[];
+    if(!bucketRecipeItems.length){const option=document.createElement('option');option.value='';option.textContent='Refresh to list saved recipe libraries';options.push(option);}
+    for(const item of bucketRecipeItems){const option=document.createElement('option');option.value=item.key;option.textContent=item.label+' · '+item.bytes+' bytes';options.push(option);}
+    recipeSelect.replaceChildren(...options);
+    if(options.length)recipeSelect.value=bucketRecipeSelectedKey&&bucketRecipeItems.some(item=>item.key===bucketRecipeSelectedKey)?bucketRecipeSelectedKey:'';
+  }
   buttons();
 }
 const bucketKeyValid=key=>typeof key==='string'&&(
   /^ald-exports\/(?:[0-9a-f]{32}|[0-9a-f]{64})\/bundle\.json$/.test(key)||
   /^ald-exports\/\d{8}T\d{6}Z-[a-z0-9-]{1,64}-(?:formula|rally|snowmobile|truck)-g\d{1,4}-lap(?:\d{1,16}ms|none)-[0-9a-f]{32}\/bundle\.json$/.test(key));
+const bucketRecipeKeyValid=key=>typeof key==='string'&&/^ald-recipes\/\d{8}T\d{6}Z-[0-9a-f]{32}\/library\.json$/.test(key);
 function bucketSnapshot(){return {token:bucketToken,id:bucketId,epoch:bucketEpoch};}
 function bucketSnapshotCurrent(snapshot){return !!snapshot?.token&&snapshot.epoch===bucketEpoch&&snapshot.token===bucketToken&&snapshot.id===bucketId;}
 function clearBucketConnection(snapshot=null){
@@ -101,14 +140,16 @@ function clearBucketConnection(snapshot=null){
   bucketEpoch++;
   bucketOperationId++;bucketOperation=false;
   bundleRestoreId++;bundleRestoring=false;
-  bucketToken=null;bucketId=null;bucketUsername=null;bucketItems=[];bucketSelectedKey=null;
+  bucketToken=null;bucketId=null;bucketUsername=null;bucketItems=[];bucketSelectedKey=null;bucketRecipeItems=[];bucketRecipeSelectedKey=null;
   if($('bucket_id'))$('bucket_id').value='';
   if($('bucket_status'))$('bucket_status').textContent='Bucket connection cleared. Reconnect to continue.';
+  if($('bucket_recipe_status'))$('bucket_recipe_status').textContent='Bucket connection cleared. Reconnect to continue.';
   renderBucketConnection();
   return true;
 }
 async function bucketRequest(endpoint,body,snapshot){
-  if(!['connect','list','save','restore'].includes(endpoint))throw Error('Unsupported bucket action');
+  if(!['connect','list','save','restore','recipes/save','recipes/list','recipes/restore'].includes(endpoint))throw Error('Unsupported bucket action');
+  if(endpoint!=='connect'&&!bucketSnapshotCurrent(snapshot))throw Error('Bucket connection changed; no request was sent.');
   const current=()=>endpoint==='connect'
     ? snapshot.epoch===bucketEpoch&&bucketToken===null&&bucketId===null
     : bucketSnapshotCurrent(snapshot);
@@ -122,7 +163,7 @@ function beginBucketOperation(){bucketOperation=true;const id=++bucketOperationI
 function endBucketOperation(id){if(id!==bucketOperationId)return;bucketOperation=false;buttons();}
 async function saveBucketBundleText(text,snapshot){
   if(!bucketSnapshotCurrent(snapshot))throw Error('Bucket connection changed; no save was attempted.');
-  const bytes=new TextEncoder().encode(text);if(bytes.byteLength>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 8 MiB');
+  const bytes=new TextEncoder().encode(text);if(bytes.byteLength>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 48 MiB');
   const sha256=await window.PortableBundle.sha(bytes);
   const response=await bucketRequest('save',{bucket_id:snapshot.id,bundle:text},snapshot),result=await response.json();
   if(!bucketSnapshotCurrent(snapshot))throw Error('Bucket connection changed; the old save response was ignored.');
@@ -209,6 +250,81 @@ if($('bucket_refresh'))$('bucket_refresh').onclick=async()=>{
   catch(error){if(bucketSnapshotCurrent(snapshot))$('bucket_status').textContent=error.message||'Could not refresh saved bundles.';}
   finally{endBucketOperation(operationId);}
 };
+function bucketRecipeTime(item){
+  if(typeof item.created_at==='string'){
+    const m=item.created_at.match(/^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(?:\.(\d{1,6}))?Z$/);
+    if(m){const p=m.slice(1,7).map(Number),t=Date.UTC(p[0],p[1]-1,p[2],p[3],p[4],p[5]),d=new Date(t);
+      if(d.getUTCFullYear()===p[0]&&d.getUTCMonth()===p[1]-1&&d.getUTCDate()===p[2]&&d.getUTCHours()===p[3]&&d.getUTCMinutes()===p[4]&&d.getUTCSeconds()===p[5])return t+Number((m[7]||'').padEnd(6,'0')||0)/1000;}
+  }
+  const m=item.key.match(/^ald-recipes\/(\d{4})(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z-/);if(!m)return null;
+  const p=m.slice(1).map(Number),t=Date.UTC(p[0],p[1]-1,p[2],p[3],p[4],p[5]),d=new Date(t);
+  return d.getUTCFullYear()===p[0]&&d.getUTCMonth()===p[1]-1&&d.getUTCDate()===p[2]&&d.getUTCHours()===p[3]&&d.getUTCMinutes()===p[4]&&d.getUTCSeconds()===p[5]?t:null;
+}
+async function refreshBucketRecipes(snapshot,{selectKey=null}={}){
+  const response=await bucketRequest('recipes/list',{bucket_id:snapshot.id},snapshot),result=await response.json();
+  if(!bucketSnapshotCurrent(snapshot))return;
+  if(!Array.isArray(result?.items)||result.items.length>50||typeof result.truncated!=='boolean'||typeof result.scan_incomplete!=='boolean')throw Error('The saved recipe library list was not valid.');
+  const checked=result.items.map(item=>{
+    if(!bucketRecipeKeyValid(item?.key)||!Number.isSafeInteger(item.bytes)||item.bytes<2||item.bytes>32768||typeof item.label!=='string'||!item.label.trim()||item.label.length>160||!(item.created_at===undefined||item.created_at===null||(typeof item.created_at==='string'&&bucketRecipeTime(item)!==null)))throw Error('The saved recipe library list was not valid.');
+    return {key:item.key,bytes:item.bytes,label:item.label,created_at:item.created_at??null};
+  }).sort((a,b)=>(bucketRecipeTime(b)??-1)-(bucketRecipeTime(a)??-1));
+  bucketRecipeItems=checked;
+  bucketRecipeSelectedKey=selectKey&&checked.some(item=>item.key===selectKey)?selectKey:(checked[0]?.key??null);
+  renderBucketConnection();
+  const caveat=result.scan_incomplete?' The bounded scan was incomplete, so a newer saved library may exist.':result.truncated?' Showing up to 50 newest listed libraries; additional libraries may exist.':'';
+  if($('bucket_recipe_status'))$('bucket_recipe_status').textContent=selectKey&&!bucketRecipeSelectedKey
+    ?'Recipe library was saved and read back but is not in the returned list. Use Refresh saved recipe libraries.'+caveat
+    :checked.length
+      ?(selectKey?'Recipe library saved, read back and selected.':'Saved recipe libraries refreshed; the newest listed library is selected.')+caveat
+      :'No saved recipe libraries were found.'+(result.scan_incomplete?' The bounded scan was incomplete; additional libraries may exist.':'');
+}
+if($('bucket_recipe_refresh'))$('bucket_recipe_refresh').onclick=async()=>{
+  if(!bucketToken)return;
+  const snapshot=bucketSnapshot(),operationId=beginBucketOperation();$('bucket_recipe_status').textContent='Refreshing saved recipe libraries…';
+  try{await refreshBucketRecipes(snapshot);}
+  catch(error){if(bucketSnapshotCurrent(snapshot))$('bucket_recipe_status').textContent=error.message||'Could not refresh saved recipe libraries.';}
+  finally{endBucketOperation(operationId);}
+};
+if($('bucket_recipe_items'))$('bucket_recipe_items').addEventListener('change',()=>{bucketRecipeSelectedKey=$('bucket_recipe_items').value||null;buttons();});
+if($('bucket_recipe_save'))$('bucket_recipe_save').onclick=async()=>{
+  if(!bucketToken)return;
+  const snapshot=bucketSnapshot(),operationId=beginBucketOperation();let readbackVerified=false;$('bucket_recipe_status').textContent='Saving and verifying the validated recipe library…';
+  try{
+    const text=window.recipeLibraryText?.();if(typeof text!=='string')throw Error('The local recipe library is unavailable.');
+    window.RecipeLibrary?.parse(text);
+    const bytes=new TextEncoder().encode(text);if(bytes.byteLength>32768)throw Error('Recipe library exceeds 32 KB');
+    const sha256=await window.PortableBundle.sha(bytes);
+    const response=await bucketRequest('recipes/save',{bucket_id:snapshot.id,library:text},snapshot),result=await response.json();
+    if(!bucketSnapshotCurrent(snapshot))return;
+    if(result?.status!=='saved_verified'||result.bucket_id!==snapshot.id||!bucketRecipeKeyValid(result.key)||result.bytes!==bytes.byteLength||result.sha256!==sha256)throw Error('Recipe library save could not be verified; the remote save may have completed.');
+    const readback=await bucketRequest('recipes/restore',{bucket_id:snapshot.id,key:result.key},snapshot),restoredText=await readback.text();
+    if(!bucketSnapshotCurrent(snapshot))return;
+    const restoredBytes=new TextEncoder().encode(restoredText);
+    if(restoredBytes.byteLength!==bytes.byteLength||await window.PortableBundle.sha(restoredBytes)!==sha256||restoredText!==text)throw Error('Recipe library readback did not match the saved bytes.');
+    window.RecipeLibrary.parse(restoredText);
+    readbackVerified=true;
+    try{await refreshBucketRecipes(snapshot,{selectKey:result.key});}
+    catch{$('bucket_recipe_status').textContent='Recipe library was saved and read back successfully, but the saved list could not refresh. Use Refresh saved recipe libraries.';}
+  }catch(error){if(bucketSnapshotCurrent(snapshot))$('bucket_recipe_status').textContent=readbackVerified?'Recipe library was saved and read back successfully. The saved list could not refresh; use Refresh saved recipe libraries.':(error.message||'Recipe library save failed; the local library was unchanged.');}
+  finally{endBucketOperation(operationId);}
+};
+if($('bucket_recipe_import'))$('bucket_recipe_import').onclick=async()=>{
+  if(!bucketToken)return;
+  const snapshot=bucketSnapshot(),key=$('bucket_recipe_items').value;
+  if(!bucketRecipeKeyValid(key)||!bucketRecipeItems.some(item=>item.key===key)){$('bucket_recipe_status').textContent='Choose a listed recipe library to import.';return;}
+  const operationId=beginBucketOperation();$('bucket_recipe_status').textContent='Downloading and validating the selected recipe library…';
+  try{
+    const response=await bucketRequest('recipes/restore',{bucket_id:snapshot.id,key},snapshot),text=await response.text();
+    if(!bucketSnapshotCurrent(snapshot))return;
+    if(new TextEncoder().encode(text).byteLength>32768)throw Error('Recipe library exceeds 32 KB');
+    const book=window.RecipeLibrary?.parse(text);if(!book)throw Error('Recipe library validation is unavailable.');
+    if(typeof window.importRecipeLibraryText!=='function')throw Error('Recipe library import is unavailable.');
+    const imported=await window.importRecipeLibraryText(text,{source:'private bucket',isCurrent:()=>bucketSnapshotCurrent(snapshot)});
+    if(!bucketSnapshotCurrent(snapshot))return;
+    $('bucket_recipe_status').textContent=imported?'Recipe library imported locally after confirmation. No run was started.':'Import canceled. The local recipe library was unchanged.';
+  }catch(error){if(bucketSnapshotCurrent(snapshot))$('bucket_recipe_status').textContent='Recipe library not imported: '+(error.message||'validation failed')+'. The existing local library was left unchanged.';}
+  finally{endBucketOperation(operationId);}
+};
 if($('bucket_items'))$('bucket_items').addEventListener('change',()=>{bucketSelectedKey=$('bucket_items').value||null;buttons();});
 if($('bucket_autosave'))$('bucket_autosave').addEventListener('change',()=>{
   if($('bucket_autosave').checked&&$('keepServer').checked){$('keepServer').checked=false;$('bucket_status').textContent='Automatic bucket saving requires deletion after a verified download; the repeat-download option was turned off.';}
@@ -235,7 +351,7 @@ if($('bucket_restore'))$('bucket_restore').onclick=async()=>{
     const response=await bucketRequest('restore',{bucket_id:snapshot.id,key},snapshot);
     const text=await response.text();
     if(!bucketSnapshotCurrent(snapshot))return;
-    if(new TextEncoder().encode(text).byteLength>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 8 MiB');
+    if(new TextEncoder().encode(text).byteLength>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 48 MiB');
     await restorePortableText(text,{lockHeld:true,isCurrent:()=>bucketSnapshotCurrent(snapshot)});
     if(bucketSnapshotCurrent(snapshot))$('bucket_status').textContent='Bundle restored in this page only. No run started and the existing result remains available.';
   }catch(error){if(bucketSnapshotCurrent(snapshot))$('bucket_status').textContent='Bundle not restored: '+(error.message||'validation failed')+'. Existing selections and results were left unchanged.';}
@@ -263,7 +379,7 @@ function saveLocal() {
   setTimeout(()=>URL.revokeObjectURL(url),60000);
 }
 $('saveLocal').onclick=saveLocal;
-$('forgetLocal').onclick=()=>{localResult=null;buttons();say('Browser result discarded. Downloaded files are unaffected.');};
+$('forgetLocal').onclick=()=>{localResult=null;localAnalysis=null;pairedAnalysisPending=false;buttons();say('Browser result discarded. Downloaded files are unaffected.');};
 async function request(path, options = {}) {
   const response = await fetch(path, {...options, cache:'no-store', credentials:'same-origin'});
   if (!response.ok) {
@@ -280,7 +396,7 @@ async function encoded(file) {
 }
 const headers = () => ({'X-Job-Key':job.key});
 const networkSource=()=>stagedNetwork || $('network').files[0];
-$('network').onchange=()=>{stagedNetwork=null;if($('networkChoice'))$('networkChoice').textContent='Uploaded file selected.';buttons();};
+$('network').onchange=()=>{stagedNetwork=null;selectedWinner=null;if($('networkChoice'))$('networkChoice').textContent='Uploaded file selected.';buttons();};
 window.TrainingClient={
   isBusy:()=>busy||!!job||bundleRestoring,
   hasUnsavedState:()=>!!(networkSource()||localResult||$('track').files.length||trackLibrary?.info?.()?.source==='builtin'||$('editor_file')?.files.length||window.hasUnsavedNetworkDraft?.()),
@@ -372,12 +488,282 @@ async function receive(current){
   const bytes=await response.arrayBuffer();
   const digest=await sha(bytes);
   if(bytes.byteLength!==current.size || digest!==current.sha256)throw Error('Result validation failed; no deletion acknowledgment sent. Use Delete now or await expiry.');
-  return {bytes,receipt:response.headers.get('x-delivery-receipt')};
+  const receipt=response.headers.get('x-delivery-receipt');if(typeof receipt!=='string'||!receipt)throw Error('Primary delivery receipt is missing; no deletion acknowledgment sent.');
+  if(current.analysis===undefined||current.analysis===null)return {bytes,receipt,analysisBytes:null,analysisReceipt:null,analysis:null};
+  const verifiedPrimary={bytes,receipt,digest};
+  try{
+    const descriptor=current.analysis;
+    if(!descriptor||!Number.isInteger(descriptor.size)||descriptor.size<1||descriptor.size>ANALYSIS_ARCHIVE_MAX||!hex64(descriptor.sha256))throw Error('Analysis archive metadata is invalid; no deletion acknowledgment sent.');
+    const analysisResponse=await request('/api/jobs/'+current.id+'/analysis/download',{method:'POST',headers:{'X-Job-Key':current.key}}),analysisBytes=await analysisResponse.arrayBuffer();
+    if(analysisBytes.byteLength!==descriptor.size||await sha(analysisBytes)!==descriptor.sha256)throw Error('Analysis archive validation failed; no deletion acknowledgment sent.');
+    const analysisReceipt=analysisResponse.headers.get('x-analysis-delivery-receipt');if(typeof analysisReceipt!=='string'||!analysisReceipt)throw Error('Analysis delivery receipt is missing; no deletion acknowledgment sent.');
+    const parsed=await parseRunAnalysisArchive(new Uint8Array(analysisBytes),descriptor,current.report?.analysis_summary);
+    try{validatePrimaryAnalysisMatch(digest,parsed);}catch(error){throw Error(error.message+'; no deletion acknowledgment sent.');}
+    if(comparisonPlan){const expected=comparisonPlan.conditions,actual=parsed.summary.conditions;
+      for(const key of ['track_sha256','vehicle_type','requested_ticks','control_hz','collision','idle','math_profile','clean_min_laps'])if(actual[key]!==expected[key])throw Error('Frozen comparison conditions changed at '+key+'; this result was not added to the comparison');
+      if(parsed.mode!=='evaluate'||parsed.summary.execution_backend!==(comparisonPlan.backend==='gpu'?'cuda':'cpu'))throw Error('Frozen comparison result does not match the requested mode or backend');
+      const buildId=current.report?.build?.build_id??current.report?.build_id;
+      if(comparisonPlan.build_id&&buildId!==comparisonPlan.build_id)throw Error('Frozen comparison engine build changed; this result was not added');
+      const role=comparisonPlan.roles[comparisonPlan.index],expectedNetwork=comparisonPlan.winnerNetworks?.[role]?.sha256;
+      if(expectedNetwork&&parsed.summary.conditions.network_sha256!==expectedNetwork)throw Error('Frozen evaluation used a different policy than the selected comparison candidate');
+    }
+    return {bytes,receipt,analysisBytes,analysisReceipt,analysis:parsed};
+  }catch(error){if(error&&typeof error==='object')error.verifiedPrimary=verifiedPrimary;throw error;}
 }
-async function acknowledge(current,receipt){
-  return (await request('/api/jobs/'+current.id+'/ack',{method:'POST',headers:{'X-Job-Key':current.key,'Content-Type':'application/json'},body:JSON.stringify({receipt})})).json();
+function retainVerifiedPrimary(error){
+  if(!error?.verifiedPrimary)return false;
+  localResult=new Blob([error.verifiedPrimary.bytes]);localAnalysis=null;pairedAnalysisPending=true;
+  renderAnalysisPanel();buttons();
+  return true;
+}
+async function acknowledge(current,received){
+  const body={receipt:received.receipt};if(received.analysisReceipt)body.analysis_receipt=received.analysisReceipt;
+  return (await request('/api/jobs/'+current.id+'/ack',{method:'POST',headers:{'X-Job-Key':current.key,'Content-Type':'application/json'},body:JSON.stringify(body)})).json();
 }
 async function sha(bytes){return Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256',bytes)),x=>x.toString(16).padStart(2,'0')).join('');}
+const ANALYSIS_ARCHIVE_MAX=32*1024*1024,ANALYSIS_EXPANDED_MAX=256*1024*1024,ANALYSIS_ROWS_MAX=128000;
+const hex64=value=>typeof value==='string'&&/^[a-f0-9]{64}$/.test(value);
+function exactAnalysisKeys(value,keys){if(!value||typeof value!=='object'||Array.isArray(value)||Object.keys(value).sort().join()!==[...keys].sort().join())throw Error('Analysis archive contains unexpected fields');}
+function stableJson(value){if(Array.isArray(value))return '['+value.map(stableJson).join(',')+']';if(value&&typeof value==='object')return '{'+Object.keys(value).sort().map(key=>JSON.stringify(key)+':'+stableJson(value[key])).join(',')+'}';return JSON.stringify(value);}
+function finiteOrNull(value,min=-1e12,max=1e12){return value===null||(typeof value==='number'&&Number.isFinite(value)&&value>=min&&value<=max);}
+function b64Bytes(text,limit){
+  if(typeof text!=='string'||text.length>Math.ceil(limit/3)*4+8)throw Error('Analysis file exceeds its size limit');
+  let binary;try{binary=atob(text);}catch{throw Error('Analysis archive contains invalid base64');}
+  const bytes=Uint8Array.from(binary,c=>c.charCodeAt(0));
+  if(bytes.byteLength>limit||btoa(binary)!==text)throw Error('Analysis archive contains noncanonical or oversized bytes');
+  return bytes;
+}
+async function expandAnalysisGzip(bytes){
+  if(typeof DecompressionStream!=='function')throw Error('This browser cannot expand the verified analysis archive');
+  const reader=new Blob([bytes]).stream().pipeThrough(new DecompressionStream('gzip')).getReader(),parts=[];let total=0;
+  try{while(true){const {value,done}=await reader.read();if(done)break;total+=value.byteLength;if(total>ANALYSIS_EXPANDED_MAX)throw Error('Expanded analysis exceeds 256 MiB');parts.push(value);}}
+  finally{reader.releaseLock();}
+  const out=new Uint8Array(total);let offset=0;for(const part of parts){out.set(part,offset);offset+=part.byteLength;}return out;
+}
+function validateAnalysisSummary(summary){
+  exactAnalysisKeys(summary,['schema','version','mode','execution_backend','conditions','observations','winners','semantics']);
+  if(summary.schema!=='ald.run-analysis'||summary.version!==1||!['train','evaluate'].includes(summary.mode)||!['cpu','cuda'].includes(summary.execution_backend))throw Error('Analysis summary identity is invalid');
+  const c=summary.conditions;exactAnalysisKeys(c,['track_sha256','network_sha256','vehicle_type','requested_ticks','control_hz','collision','idle','math_profile','clean_min_laps']);
+  if(!hex64(c.track_sha256)||!hex64(c.network_sha256)||!Number.isInteger(c.vehicle_type)||c.vehicle_type<0||c.vehicle_type>3||!Number.isInteger(c.requested_ticks)||c.requested_ticks<1||c.requested_ticks>18000||![15,30,60].includes(c.control_hz)||typeof c.collision!=='boolean'||typeof c.idle!=='boolean'||c.math_profile!=='proton'||!Number.isInteger(c.clean_min_laps)||c.clean_min_laps<1||c.clean_min_laps>100)throw Error('Analysis conditions are invalid');
+  const o=summary.observations;exactAnalysisKeys(o,['generations','cars','raw_metric_count','reward_channel_count']);
+  if(!Number.isInteger(o.generations)||o.generations<1||o.generations>1000||!Number.isInteger(o.cars)||o.cars<1||o.cars>ANALYSIS_ROWS_MAX||o.raw_metric_count!==14||o.reward_channel_count!==18)throw Error('Analysis observation counts are invalid');
+  exactAnalysisKeys(summary.winners,['fitness','fastest_lap','clean_laps']);
+  for(const role of ['fitness','fastest_lap','clean_laps']){
+    const w=summary.winners[role];exactAnalysisKeys(w,['status','reason','candidate_id','generation','car','selection_fitness','best_lap_seconds','forward_laps','physical_contacts','collision_updates','total_actual_distance','artifact']);
+    if(!['available','unavailable'].includes(w.status))throw Error('Winner status is invalid');
+    if(w.status==='unavailable'){
+      if(typeof w.reason!=='string'||!w.reason||w.reason.length>300||w.candidate_id!==null||w.artifact!==null)throw Error('Unavailable winner details are invalid');
+    }else{
+      if(w.reason!==null||typeof w.candidate_id!=='string'||!/^g\d{6}-c\d{6}$/.test(w.candidate_id)||!Number.isInteger(w.generation)||w.generation<1||w.generation>o.generations||!Number.isInteger(w.car)||w.car<0||w.car>=128||!finiteOrNull(w.selection_fitness)||!finiteOrNull(w.best_lap_seconds,Number.MIN_VALUE,1e12)||!Number.isInteger(w.forward_laps)||w.forward_laps<0||!Number.isInteger(w.physical_contacts)||w.physical_contacts<0||!Number.isInteger(w.collision_updates)||w.collision_updates<0||!finiteOrNull(w.total_actual_distance,0,1e12))throw Error('Available winner details are invalid');
+      exactAnalysisKeys(w.artifact,['name','bytes','sha256']);if(w.artifact.name!=='winners/'+role+'.evolution'||!Number.isInteger(w.artifact.bytes)||w.artifact.bytes<1||w.artifact.bytes>4*1024*1024||!hex64(w.artifact.sha256))throw Error('Winner artifact reference is invalid');
+    }
+  }
+  if(typeof summary.semantics!=='object'||Array.isArray(summary.semantics))throw Error('Analysis semantics are invalid');
+  exactAnalysisKeys(summary.semantics,['fitness','fastest_lap','clean_laps','channels','collision_count','training','evaluation']);
+  if(Object.values(summary.semantics).some(x=>typeof x!=='string'||x.length>1000))throw Error('Analysis semantics are invalid');
+  if(summary.mode==='evaluate'&&Object.values(summary.winners).some(w=>w.status!=='unavailable'||w.reason!=='frozen_evaluation_does_not_select_winners'))throw Error('Frozen evaluation must not select winners');
+  return summary;
+}
+function validateDescriptorRow(row,metricNames,rewardChannels){
+  exactAnalysisKeys(row,['schema','generation','car','candidate_id','ticks_elapsed','stats_update_count','raw_metrics','channels','selection_fitness','objectives','weights_sha256']);
+  if(row.schema!==1||!Number.isInteger(row.generation)||row.generation<1||row.generation>1000||!Number.isInteger(row.car)||row.car<0||row.car>=128||row.candidate_id!=='g'+String(row.generation).padStart(6,'0')+'-c'+String(row.car).padStart(6,'0')||!Number.isInteger(row.ticks_elapsed)||row.ticks_elapsed<0||row.ticks_elapsed>18012||!Number.isInteger(row.stats_update_count)||row.stats_update_count<0||row.stats_update_count>18012||!finiteOrNull(row.selection_fitness)||!hex64(row.weights_sha256))throw Error('Analysis descriptor identity is invalid');
+  exactAnalysisKeys(row.raw_metrics,metricNames);if(Object.values(row.raw_metrics).some(value=>!finiteOrNull(value)))throw Error('Analysis raw metric is invalid');
+  exactAnalysisKeys(row.channels,['values','population_relative','unavailable_reasons']);
+  if(!Array.isArray(row.channels.values)||row.channels.values.length!==18||!Array.isArray(row.channels.population_relative)||row.channels.population_relative.length!==18||!Array.isArray(row.channels.unavailable_reasons)||row.channels.unavailable_reasons.length!==18)throw Error('Analysis reward channels are incomplete');
+  row.channels.values.forEach((value,index)=>{const rank=row.channels.population_relative[index],reason=row.channels.unavailable_reasons[index];if(!finiteOrNull(value)||!finiteOrNull(rank,0,1)||!(reason===null||['no_completed_lap','no_statistics_updates','not_observed'].includes(reason))||(value===null&&(reason===null||rank!==null))||(value!==null&&reason!==null))throw Error('Analysis reward descriptor is invalid');});
+  const obj=row.objectives;exactAnalysisKeys(obj,['best_lap_seconds','forward_laps','physical_contacts','collision_updates','total_actual_distance','active']);
+  if(!finiteOrNull(obj.best_lap_seconds,Number.MIN_VALUE,1e12)||!Number.isInteger(obj.forward_laps)||obj.forward_laps<0||!Number.isInteger(obj.physical_contacts)||obj.physical_contacts<0||!Number.isInteger(obj.collision_updates)||obj.collision_updates<0||!finiteOrNull(obj.total_actual_distance,0,1e12)||typeof obj.active!=='boolean')throw Error('Analysis objective descriptor is invalid');
+  return row;
+}
+function selectedWinnerRoles(){return [...document.querySelectorAll('[data-compare-role]:checked')].map(node=>node.dataset.compareRole).filter(role=>localAnalysis?.winnerNetworks?.[role]);}
+function uniqueWinnerRoles(roles,winnerNetworks){const seen=new Set();return roles.filter(role=>{const item=winnerNetworks?.[role];if(!item)return false;const identity=item.candidate_id||item.sha256;if(seen.has(identity))return false;seen.add(identity);return true;});}
+function conditionIdentity(summary,backend,buildId){const c=summary.conditions;return JSON.stringify({track_sha256:c.track_sha256,vehicle_type:c.vehicle_type,requested_ticks:c.requested_ticks,control_hz:c.control_hz,collision:c.collision,idle:c.idle,math_profile:c.math_profile,clean_min_laps:c.clean_min_laps,backend,build_id:buildId});}
+function validateComparisonRequest(plan,actual){
+  const expected=plan?.conditions,role=plan?.roles?.[plan.index],winner=plan?.winnerNetworks?.[role];
+  if(!expected||!winner||actual.mode!=='evaluate'||winner.sha256!==actual.network_sha256||
+     actual.track_sha256!==expected.track_sha256||actual.vehicle_type!==expected.vehicle_type||
+     actual.requested_ticks!==expected.requested_ticks||actual.control_hz!==expected.control_hz||
+     actual.collision!==expected.collision||actual.idle!==expected.idle||actual.clean_min_laps!==expected.clean_min_laps||
+     actual.backend!==plan.backend||(plan.build_id&&actual.build_id&&actual.build_id!==plan.build_id))
+    throw Error('The frozen comparison conditions or selected policy changed. The comparison was stopped before sending this run. Start a new comparison after restoring the matching settings.');
+  return true;
+}
+function renderAnalysisPanel(){
+  const panel=$('analysisPanel');if(!panel)return;
+  panel.hidden=!localAnalysis;
+  if(!localAnalysis)return;
+  const {summary}=localAnalysis,train=summary.mode==='train';
+  $('winnerTools').hidden=!train;$('evaluationTools').hidden=train;
+  $('analysisStatus').textContent=train?'Per evaluated car and distinct winner policies from this completed training run. Fitness is only meaningful within its evaluated generation.':'One unchanged policy was measured in a fresh car. No winner was selected.';
+  const tbody=$('winnerRows');tbody.replaceChildren();
+  const select=$('winner_continue');select.replaceChildren();
+  const primary=document.createElement('option');primary.value='';primary.textContent='Primary fitness result';select.append(primary);
+  const roles=[['fitness','Final fitness leader'],['fastest_lap','Fastest completed lap'],['clean_laps','Clean laps']];
+  for(const [role,label] of roles){const w=summary.winners[role],tr=document.createElement('tr');
+    const checkCell=document.createElement('td');if(w.status==='available'){const check=document.createElement('input');check.type='checkbox';check.dataset.compareRole=role;check.setAttribute('aria-label','Compare '+label);check.addEventListener('change',buttons);checkCell.append(check);}else checkCell.textContent='—';
+    const candidate=document.createElement('td');candidate.textContent=label;
+    const id=document.createElement('td');id.textContent=w.status==='available'?w.candidate_id:'Unavailable: '+w.reason;
+    const gen=document.createElement('td');gen.textContent=w.status==='available'?w.generation+' / '+w.car:'—';
+    const fitness=document.createElement('td');fitness.textContent=w.status==='available'&&w.selection_fitness!==null?w.selection_fitness.toFixed(5):'Not available';
+    const lap=document.createElement('td');lap.textContent=w.status==='available'&&w.best_lap_seconds!==null?w.best_lap_seconds.toFixed(3)+' s':'Not available';
+    const laps=document.createElement('td');laps.textContent=w.status==='available'?String(w.forward_laps):'—';
+    const contacts=document.createElement('td');contacts.textContent=w.status==='available'?String(w.physical_contacts):'—';
+    const distance=document.createElement('td');distance.textContent=w.status==='available'&&w.total_actual_distance!==null?w.total_actual_distance.toFixed(3):'Not reported';
+    const action=document.createElement('td');if(w.status==='available'){const option=document.createElement('option');option.value=role;option.textContent=label+' · '+w.candidate_id;select.append(option);const button=document.createElement('button');button.type='button';button.textContent='Use policy';button.onclick=()=>useWinner(role);const download=document.createElement('button');download.type='button';download.textContent='Download weights';download.onclick=()=>downloadBytes(localAnalysis.winnerNetworks[role].bytes,'ald-winner-'+role+'-'+w.candidate_id+'.evolution','application/octet-stream');action.append(button,download);}else action.textContent='—';
+    for(const cell of [checkCell,candidate,id,gen,fitness,lap,laps,contacts,distance,action])tr.append(cell);tbody.append(tr);
+  }
+  if($('evaluationStatus'))$('evaluationStatus').textContent=summary.mode==='evaluate'?'Frozen evaluation complete. Scores are not shown as winner fitness; these physical measurements describe this policy and conditions.':'Choose policies to compare by selecting winner roles.';
+  renderEvaluationRows();
+}
+async function useWinner(role){
+  const item=localAnalysis?.winnerNetworks?.[role]??comparisonPlan?.winnerNetworks?.[role];if(!item)throw Error('That winner policy is unavailable');
+  const file=new File([item.bytes],role+'-'+item.candidate_id+'.evolution',{type:'application/octet-stream'});
+  window.TrainingClient.useNetwork(file);selectedWinner=role;
+  if($('winner_continue'))$('winner_continue').value=role;
+  if($('run_mode'))$('run_mode').value='evaluate';syncRunModeUI();buttons();say('Selected '+role.replaceAll('_',' ')+' policy for frozen evaluation. Choose the same track and conditions for comparisons.');
+}
+function renderEvaluationRows(){
+  const tbody=$('evaluationRows');if(!tbody)return;tbody.replaceChildren();
+  for(const row of comparisonRows){
+    const tr=document.createElement('tr');
+    const policy=document.createElement('td');policy.textContent=(row.policy_label||'Selected policy')+' · '+row.network_sha256.slice(0,12);policy.title='Full policy SHA-256: '+row.network_sha256;
+    const vehicle=document.createElement('td');vehicle.textContent=row.vehicle;
+    const track=document.createElement('td');track.textContent=(row.track_label||'Selected track')+' · '+row.track_sha256.slice(0,12);track.title='Full track SHA-256: '+row.track_sha256;
+    for(const cell of [policy,vehicle,track])tr.append(cell);
+    for(const value of [String(row.requested_ticks),row.best_lap_seconds===null?'Not reported':row.best_lap_seconds.toFixed(3)+' s',String(row.forward_laps),String(row.physical_contacts),row.total_actual_distance===null?'Not reported':row.total_actual_distance.toFixed(3),row.compatible?'Same conditions':'Conditions differ']){const td=document.createElement('td');td.textContent=value;tr.append(td);}
+    tbody.append(tr);
+  }
+}
+function launchNextComparison(){
+  if(!comparisonPlan||comparisonPlan.index===0||comparisonPlan.index>=comparisonPlan.roles.length)return;
+  const expectedPlan=comparisonPlan,expectedIndex=comparisonPlan.index,role=comparisonPlan.roles[expectedIndex];
+  setTimeout(async()=>{
+    if(comparisonPlan!==expectedPlan||comparisonPlan.index!==expectedIndex||busy||job)return;
+    try{
+      await useWinner(role);
+      if(comparisonPlan===expectedPlan&&comparisonPlan.index===expectedIndex&&!busy&&!job)$('run').click();
+    }catch(error){
+      if(comparisonPlan===expectedPlan){comparisonPlan=null;$('evaluationStatus').textContent='Comparison stopped before '+role.replaceAll('_',' ')+' could start: '+error.message+' Completed results remain in the table.';buttons();}
+    }
+  },0);
+}
+function showDescriptor(){
+  if(!localAnalysis||localAnalysis.mode!=='train')return;
+  const generation=Number($('descriptor_generation').value),car=Number($('descriptor_car').value);
+  if(!Number.isInteger(generation)||!Number.isInteger(car)){ $('descriptor_status').textContent='Enter whole generation and car numbers.';return; }
+  const row=localAnalysis.descriptorRows.find(item=>item.generation===generation&&item.car===car);
+  if(!row){$('descriptor_status').textContent='No descriptor was recorded for that generation and car.';$('descriptor_tables').replaceChildren();return;}
+  const wrap=document.createElement('div');
+  const summary=document.createElement('p');summary.textContent='Candidate '+row.candidate_id+' · ticks '+row.ticks_elapsed+' · stats updates '+row.stats_update_count+' · weights '+row.weights_sha256;wrap.append(summary);
+  const table=(title,entries)=>{const h=document.createElement('h3');h.textContent=title;wrap.append(h);const t=document.createElement('table'),body=document.createElement('tbody');for(const [name,value] of entries){const tr=document.createElement('tr'),a=document.createElement('th'),b=document.createElement('td');a.textContent=name;b.textContent=value===null?'Not observed':typeof value==='number'?String(value):String(value);tr.append(a,b);body.append(tr);}t.append(body);wrap.append(t);};
+  table('Physical objectives',Object.entries(row.objectives));table('Raw metrics',Object.entries(row.raw_metrics));
+  table('Reward-channel measurements',row.channels.values.map((value,index)=>[localAnalysis.rewardChannels[index].metric+' · '+localAnalysis.rewardChannels[index].type,`${value===null?'Not observed':value} · population relative ${row.channels.population_relative[index]===null?'Not available':row.channels.population_relative[index]}${row.channels.unavailable_reasons[index]?' · '+row.channels.unavailable_reasons[index]:''}`]));
+  $('descriptor_tables').replaceChildren(wrap);$('descriptor_status').textContent='All recorded values for this evaluated car are shown; unavailable fields remain explicitly unavailable.';
+}
+async function addFrozenEvaluation(){
+  const receipt=runReceipt||portableReceipt;if(localAnalysis?.mode!=='evaluate'||!localAnalysis.evaluation||!receipt)return;
+  const evaluation=localAnalysis.evaluation,summary=localAnalysis.summary,identity=conditionIdentity(summary,receipt.backend,receipt.build?.build_id??receipt.build_id??appBuild?.build_id??'');
+  const m=evaluation.measurements,o=m.objectives;
+  const policyLabels={fitness:'Final fitness leader',fastest_lap:'Fastest lap winner',clean_laps:'Clean laps winner'},trackInfo=runResultContext?.trackInfo??trackLibrary?.info?.();
+  const policyRole=Object.entries(comparisonPlan?.winnerNetworks??localAnalysis?.winnerNetworks??{}).find(([,item])=>item.sha256===evaluation.input_sha256)?.[0]??selectedWinner;
+  const record={policy_label:policyLabels[policyRole]??'Selected policy',network_sha256:evaluation.input_sha256,vehicle:['Formula','Rally','Snowmobile','Truck'][summary.conditions.vehicle_type],track_label:trackInfo?.display_name??(trackInfo?.source==='upload'?'Custom track':'Selected track'),track_sha256:summary.conditions.track_sha256,requested_ticks:summary.conditions.requested_ticks,best_lap_seconds:o.best_lap_seconds,forward_laps:o.forward_laps,physical_contacts:o.physical_contacts,total_actual_distance:o.total_actual_distance,identity};
+  if(comparisonRows.some(row=>row.network_sha256===record.network_sha256&&row.identity===identity)){
+    if($('evaluationStatus'))$('evaluationStatus').textContent='This policy and condition set is already in the comparison.';
+    if(comparisonPlan){comparisonPlan.index++;if(comparisonPlan.index>=comparisonPlan.roles.length){$('evaluationStatus').textContent='All selected winner policies have been evaluated sequentially. Compare physical measurements; fitness is not shown as a cross-policy score.';comparisonPlan=null;}}
+    return;
+  }
+  if(comparisonRows.length&&comparisonRows.some(row=>row.identity!==identity)){record.compatible=false;comparisonRows.push(record);renderEvaluationRows();$('evaluationStatus').textContent='Conditions differ from the comparison snapshot. This policy is shown separately and is not a like-for-like comparison.';return;}
+  record.compatible=true;comparisonRows.push(record);renderEvaluationRows();$('evaluationStatus').textContent='Added unchanged policy measurements. Shared conditions match across '+comparisonRows.length+' evaluation(s); compare physical measures and retain each policy hash.';
+  if(comparisonPlan){
+    comparisonPlan.index++;
+    if(comparisonPlan.index<comparisonPlan.roles.length){const next=comparisonPlan.roles[comparisonPlan.index];$('evaluationStatus').textContent+=' Next: run '+next.replaceAll('_',' ')+' under the same conditions.';}
+    else{$('evaluationStatus').textContent='All selected winner policies have been evaluated sequentially. Compare physical measurements; fitness is not shown as a cross-policy score.';comparisonPlan=null;}
+  }
+}
+if($('compare_winners'))$('compare_winners').onclick=async()=>{
+  try{
+    const roles=selectedWinnerRoles();if(!roles.length)throw Error('Select at least one available winner role');
+    const uniqueRoles=uniqueWinnerRoles(roles,localAnalysis.winnerNetworks);roles.splice(0,roles.length,...uniqueRoles);const winners=roles.map(role=>localAnalysis.winnerNetworks[role]);
+    const trackFile=await trackSource(),settings=window.getTrainingSettings?.();if(!trackFile||!settings)throw Error('Choose a track and valid evaluation conditions first');
+    const trackBytes=new Uint8Array(await trackFile.arrayBuffer()),trackSha=await sha(trackBytes),trackInfo=trackLibrary?.info()??{source:'upload'},vehicleType=localAnalysis.summary.conditions.vehicle_type;
+    if(winners.some(item=>item.vehicle_type!==vehicleType))throw Error('Selected winner policies do not share one vehicle type');
+    const cleanMinText=$('clean_min_laps')?.value??'',cleanMinLaps=cleanMinText===''?2:Number(cleanMinText);
+    if(!Number.isInteger(cleanMinLaps)||cleanMinLaps<1||cleanMinLaps>100)throw Error('Minimum clean laps must be a whole number from 1 to 100');
+    const conditions={track_sha256:trackSha,network_sha256:'0'.repeat(64),vehicle_type:vehicleType,requested_ticks:settings.ticks,control_hz:settings.control_hz,collision:settings.collision,idle:settings.idle,math_profile:'proton',clean_min_laps:cleanMinLaps};
+    comparisonPlan={roles,index:0,conditions,backend:$('backend').value,build_id:appBuild?.build_id??runReceipt?.build?.build_id,trackInfo,trackBytes,winnerNetworks:{...localAnalysis.winnerNetworks}};
+    $('keepServer').checked=false;comparisonRows=[];renderEvaluationRows();$('run_mode').value='evaluate';syncRunModeUI();buttons();await useWinner(roles[0]);
+    $('evaluationStatus').textContent='Starting a frozen comparison of '+roles.length+' distinct winner policies. This runs one unchanged policy at a time using the selected track, horizon and control settings. No candidate weights are changed.';
+    $('run').click();
+  }catch(error){$('analysisStatus').textContent='Comparison could not start: '+error.message;$('evaluationStatus').textContent=error.message;}
+};
+if($('winner_use'))$('winner_use').onclick=()=>useWinner($('winner_continue').value||'fitness');
+if($('descriptor_show'))$('descriptor_show').onclick=showDescriptor;
+if($('compare_add'))$('compare_add').onclick=addFrozenEvaluation;
+if($('compare_clear'))$('compare_clear').onclick=()=>{comparisonRows=[];comparisonPlan=null;renderEvaluationRows();if($('evaluationStatus'))$('evaluationStatus').textContent='Comparison cleared.';};
+if($('analysis_download'))$('analysis_download').onclick=()=>{if(!localAnalysis)return;downloadTextFile(localAnalysis.archiveBytes,'ald-run-analysis.gz','application/gzip');};
+async function parseRunAnalysisArchive(bytes,descriptor,reportedSummary){
+  if(!(bytes instanceof Uint8Array)||bytes.byteLength<1||bytes.byteLength>ANALYSIS_ARCHIVE_MAX||!descriptor||descriptor.size!==bytes.byteLength||descriptor.sha256!==await sha(bytes))throw Error('Analysis archive size or SHA-256 does not match the server report');
+  if(descriptor.format!==undefined&&descriptor.format!=='ald.run-analysis-archive+gzip')throw Error('Unsupported analysis archive format');
+  const raw=await expandAnalysisGzip(bytes);let envelope;
+  try{envelope=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(raw));}catch{throw Error('Analysis archive is not valid UTF-8 JSON');}
+  exactAnalysisKeys(envelope,['schema','version','files']);if(envelope.schema!=='ald.run-analysis-archive'||envelope.version!==1||!Array.isArray(envelope.files)||envelope.files.length>6)throw Error('Analysis archive envelope is invalid');
+  const files=new Map(),allowed=new Set(['analysis.json','descriptors.jsonl','evaluation.json','winners/fitness.evolution','winners/fastest_lap.evolution','winners/clean_laps.evolution']);
+  for(const file of envelope.files){
+    exactAnalysisKeys(file,['name','bytes','sha256','data_base64']);
+    if(typeof file.name!=='string'||!allowed.has(file.name)||files.has(file.name)||!Number.isInteger(file.bytes)||file.bytes<1||file.bytes>ANALYSIS_EXPANDED_MAX||!hex64(file.sha256))throw Error('Analysis archive file manifest is invalid');
+    const content=b64Bytes(file.data_base64,ANALYSIS_EXPANDED_MAX);
+    if(content.byteLength!==file.bytes||await sha(content)!==file.sha256)throw Error('Analysis archive inner file failed size or SHA-256 verification');
+    files.set(file.name,{bytes:content,sha256:file.sha256});
+  }
+  if(!files.has('analysis.json')||!files.has('descriptors.jsonl'))throw Error('Analysis archive is missing required descriptors');
+  let analysis;try{analysis=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(files.get('analysis.json').bytes));}catch{throw Error('Analysis summary file is invalid JSON');}
+  exactAnalysisKeys(analysis,['schema','version','mode','execution_backend','conditions','observations','winners','semantics','metric_names','reward_channels','settings','descriptors']);
+  const summary=validateAnalysisSummary(reportedSummary);
+  for(const key of ['schema','version','mode','execution_backend','conditions','observations','winners','semantics'])if(stableJson(analysis[key])!==stableJson(summary[key]))throw Error('Analysis archive does not match the public run summary');
+  const metricNames=analysis.metric_names;
+  if(!Array.isArray(metricNames)||metricNames.length!==14||metricNames.some(x=>typeof x!=='string'||x.length>80)||new Set(metricNames).size!==14)throw Error('Analysis metric catalog is invalid');
+  const rewardChannels=analysis.reward_channels;
+  if(!Array.isArray(rewardChannels)||rewardChannels.length!==18||rewardChannels.some(x=>!x||typeof x.metric!=='string'||!['default','average'].includes(x.type)))throw Error('Analysis reward catalog is invalid');
+  if(!analysis.settings||typeof analysis.settings!=='object'||Array.isArray(analysis.settings))throw Error('Analysis settings are invalid');
+  exactAnalysisKeys(analysis.descriptors,['name','bytes','sha256','rows']);
+  const descriptorFile=files.get('descriptors.jsonl');if(analysis.descriptors.name!=='descriptors.jsonl'||analysis.descriptors.bytes!==descriptorFile.bytes.byteLength||analysis.descriptors.sha256!==descriptorFile.sha256||!Number.isInteger(analysis.descriptors.rows)||analysis.descriptors.rows<1||analysis.descriptors.rows>ANALYSIS_ROWS_MAX||analysis.descriptors.rows!==summary.observations.cars)throw Error('Descriptor file metadata is inconsistent');
+  const descText=new TextDecoder('utf-8',{fatal:true}).decode(descriptorFile.bytes),offsets=[],descriptorRows=[],candidateIds=new Set();let cursor=0;
+  while(cursor<descText.length){const end=descText.indexOf('\n',cursor),stop=end<0?descText.length:end;if(stop===cursor){cursor=stop+1;continue;}if(offsets.length>=ANALYSIS_ROWS_MAX)throw Error('Analysis descriptor row limit exceeded');let row;try{row=JSON.parse(descText.slice(cursor,stop));}catch{throw Error('Analysis descriptor row is invalid JSON');}validateDescriptorRow(row,metricNames,rewardChannels);if(candidateIds.has(row.candidate_id))throw Error('Analysis descriptor candidate identity is duplicated');candidateIds.add(row.candidate_id);descriptorRows.push(row);offsets.push([cursor,stop]);cursor=end<0?descText.length:stop+1;}
+  if(offsets.length!==analysis.descriptors.rows)throw Error('Analysis descriptor count does not match its manifest');
+  const winnerNetworks={};
+  for(const role of ['fitness','fastest_lap','clean_laps']){
+    const winner=summary.winners[role],name='winners/'+role+'.evolution',file=files.get(name);
+    if(winner.status==='available'){
+      if(!file||winner.artifact.bytes!==file.bytes.byteLength||winner.artifact.sha256!==file.sha256)throw Error('Winner network is missing or does not match its descriptor');
+      const matched=descriptorRows.find(row=>row.generation===winner.generation&&row.car===winner.car&&row.candidate_id===winner.candidate_id);
+      if(!matched)throw Error('Winner candidate is missing from the descriptor rows');
+      const network=await validateNetworkBytes(file.bytes);if(network.Type!==summary.conditions.vehicle_type)throw Error('Winner network vehicle type does not match analysis conditions');
+      winnerNetworks[role]={bytes:file.bytes,sha256:file.sha256,candidate_id:winner.candidate_id,vehicle_type:summary.conditions.vehicle_type};
+    }else if(file)throw Error('Unavailable winner unexpectedly has a network artifact');
+  }
+  let evaluation=null;
+  if(summary.mode==='evaluate'){
+    const f=files.get('evaluation.json');if(!f)throw Error('Frozen evaluation archive is missing its result');
+    try{evaluation=JSON.parse(new TextDecoder('utf-8',{fatal:true}).decode(f.bytes));}catch{throw Error('Frozen evaluation result is invalid JSON');}
+    exactAnalysisKeys(evaluation,['schema','version','conditions','input_sha256','weights_unchanged','measurements']);
+    if(evaluation.schema!=='ald.frozen-evaluation'||evaluation.version!==1||stableJson(evaluation.conditions)!==stableJson(summary.conditions)||evaluation.input_sha256!==summary.conditions.network_sha256||evaluation.weights_unchanged!==true)throw Error('Frozen evaluation identity is invalid');
+    validateDescriptorRow(evaluation.measurements,metricNames,rewardChannels);
+  }else if(files.has('evaluation.json'))throw Error('Training archive unexpectedly contains frozen evaluation data');
+  const expectedFiles=new Set(['analysis.json','descriptors.jsonl',...(summary.mode==='evaluate'?['evaluation.json']:[]),...Object.entries(summary.winners).filter(([,w])=>w.status==='available').map(([role])=>'winners/'+role+'.evolution')]);
+  if(files.size!==expectedFiles.size||[...files.keys()].some(name=>!expectedFiles.has(name)))throw Error('Analysis archive contains missing or unexpected files');
+  return {mode:summary.mode,summary,analysis,winnerNetworks,evaluation,archiveBytes:bytes,descriptorText:descText,descriptorOffsets:offsets,descriptorRows,rawMetrics:metricNames,rewardChannels};
+}
+function validatePrimaryAnalysisMatch(primarySha,parsed){
+  if(!hex64(primarySha)||!parsed?.summary)throw Error('Primary result and analysis are not verifiable');
+  if(parsed.mode==='train'){
+    const fitness=parsed.winnerNetworks?.fitness;
+    if(!fitness||fitness.sha256!==primarySha)throw Error('Primary result is not the archived final fitness winner');
+  }else if(parsed.mode==='evaluate'){
+    if(parsed.summary.conditions.network_sha256!==primarySha)throw Error('Frozen evaluation result does not preserve the submitted policy bytes');
+  }else throw Error('Analysis mode is unsupported');
+  return true;
+}
+window.RunAnalysis={parseArchive:parseRunAnalysisArchive,validatePrimaryMatch:validatePrimaryAnalysisMatch,validateComparisonRequest,uniqueWinnerRoles};
 function showDetails(r){
   const metric=n=>typeof n==='number'?n.toFixed(3):'Not reported';
   if($('effectiveSettings'))$('effectiveSettings').textContent=JSON.stringify(r?.settings??{},null,2);
@@ -385,12 +771,13 @@ function showDetails(r){
     'Generation '+h.generation+' · mutation '+metric(h.mutation)+' · best '+metric(h.best_score)+' · mean '+metric(h.mean_score)+' · lap '+(h.best_lap_seconds??'none')+' · cars lapped '+(h.lapped_cars??'not reported')+' · ticks '+metric(h.simulated_ticks)).join('\n');
 }
 $('run').onclick = async () => {
+  const comparisonAttempt=!!comparisonPlan,comparisonRole=comparisonAttempt?comparisonPlan.roles[comparisonPlan.index]:null;
   cancelSteamLeaderboard();
   if($('leaderboard_status'))$('leaderboard_status').textContent='';
   const started=performance.now();
   $('runState').textContent='RUNNING — waiting for server confirmation';
   $('runState').style.color='#ffd073';
-  runReceipt=null;
+  runReceipt=null;pairedAnalysisPending=false;
   runResultContext=null;
   showDetails(null);
   const tick=()=>{$('runSummary').textContent='Backend: '+$('backend').value.toUpperCase()+'\nElapsed: '+((performance.now()-started)/1000).toFixed(1)+' s\nCompletion is not yet confirmed.';};
@@ -400,12 +787,22 @@ $('run').onclick = async () => {
     const trackInfo=trackLibrary?.info()??{source:'upload'};
     const trackFile=await trackSource(),networkFile=networkSource();
     const trackBytes=new Uint8Array(await trackFile.arrayBuffer()),networkBytes=new Uint8Array(await networkFile.arrayBuffer());
+    const networkValue=await validateNetworkBytes(networkBytes),settings=window.getTrainingSettings?.()??{};
+    const cleanMinText=$('clean_min_laps')?.value??'',cleanMinLaps=cleanMinText===''?2:Number(cleanMinText);
+    if(!Number.isInteger(cleanMinLaps)||cleanMinLaps<1||cleanMinLaps>100)throw Error('Minimum clean laps must be a whole number from 1 to 100.');
+    if(comparisonPlan){
+      try{validateComparisonRequest(comparisonPlan,{mode:$('run_mode')?.value==='evaluate'?'evaluate':'train',network_sha256:await sha(networkBytes),
+        track_sha256:await sha(trackBytes),vehicle_type:networkValue?.Type,requested_ticks:settings.ticks,control_hz:settings.control_hz,
+        collision:settings.collision,idle:settings.idle,clean_min_laps:cleanMinLaps,backend:$('backend').value,build_id:appBuild?.build_id});}
+      catch(error){comparisonPlan=null;throw error;}
+    }
     const autosaveSnapshot=bucketToken&&$('bucket_autosave')?.checked?bucketSnapshot():null;
     if(autosaveSnapshot)$('keepServer').checked=false;
     const context={trackInfo,trackBytes,inputNetworkSha256:await sha(networkBytes),autosaveSnapshot};
     const body={track:await encoded(trackFile),network:await encoded(networkFile),automatic:autosaveSnapshot?true:!$('keepServer').checked,backend:$('backend').value};
-    if(window.getTrainingSettings)body.settings=window.getTrainingSettings();
-    job=await submit(body);localResult=null;
+    if(window.getTrainingSettings){body.settings={...settings};body.settings.mode=$('run_mode')?.value==='evaluate'?'evaluate':'train';body.settings.clean_min_laps=cleanMinLaps;
+      if(body.settings.mode==='evaluate')Object.assign(body.settings,{population:1,generations:1,mutation:0,mutation_end:0,schedule:'fixed',selection:'best',parents:1,elite:0,crossover:'none',decay:0,adaptive_mutation:false});}
+    job=await submit(body);localResult=null;localAnalysis=null;pairedAnalysisPending=false;selectedWinner=null;renderAnalysisPanel();
     clearInterval(progress);
     $('runState').textContent='COMPLETE — candidate ready to download';
     $('runState').style.color='#62dfb1';
@@ -420,7 +817,7 @@ $('run').onclick = async () => {
       'Track: '+(trackInfo?.source==='builtin'?trackInfo.display_name:'Custom upload'),
       'Generations: '+r.generations_completed+' / '+r.generations_requested+' · Population: '+r.population,
       'Server processing: '+metric(r.elapsed_seconds)+' s',
-      'Final-generation population scores — best: '+metric(r.best_score)+' · mean: '+metric(r.mean_score),
+      ...(r.mode==='evaluate'||r.analysis_summary?.mode==='evaluate'?['Mode: FROZEN EVALUATION · weights unchanged']:['Final-generation population scores — best: '+metric(r.best_score)+' · mean: '+metric(r.mean_score)]),
       'Best completed lap observed during this run (may be another car): '+(r.best_lap_seconds==null?'No completed lap':metric(r.best_lap_seconds)+' s'),
       'Cars completing a lap in the final generation: '+(r.lapped_cars??'Not reported'),
       'Actual frames (including stats cutoff): '+(r.simulated_ticks??'Not reported')+' · Configured time limit: '+r.requested_ticks+' ticks',
@@ -430,7 +827,7 @@ $('run').onclick = async () => {
     showDetails(r);
     if($('leaderboard_opt_in')?.checked)void checkSteamLeaderboard(trackInfo,r);
     else if($('leaderboard_status'))$('leaderboard_status').textContent='';
-    $('track').value=''; $('network').value='';
+    if(!comparisonPlan)$('track').value=''; $('network').value='';
     stagedNetwork=null;if($('networkChoice'))$('networkChoice').textContent='Network input released after the run.';
     say('Result ready ('+job.backend.toUpperCase()+'). Inputs and intermediate worker files have been removed.');
     if(autosaveSnapshot){
@@ -442,7 +839,14 @@ $('run').onclick = async () => {
         try{await refreshBucketItems(autosaveSnapshot,{selectKey:outcome.saved.key,preflight:false});}
         catch{$('bucket_status').textContent='Network and run log were saved and verified. The saved-bundle list could not refresh; use Refresh saved bundles.';}
       }catch(error){
-        if(!context.localVerified){
+        if(comparisonAttempt&&context.serverDeleted)comparisonPlan=null;
+        if(retainVerifiedPrimary(error)){
+          context.localPrimaryVerified=true;
+          $('runSummary').textContent+='\nThe primary network was verified and is available locally, but its paired analysis did not verify. No acknowledgment or bucket save was attempted. Retry Download result while the server result remains available.';
+          $('bucket_status').textContent='Primary network verified locally; paired analysis is pending. No bucket save was attempted.';
+          $('runState').textContent='COMPLETE — primary network verified; analysis pending';$('runState').style.color='#ffd073';
+          say('Primary network verified. Paired analysis is pending; retry Download result.');
+        }else if(!context.localVerified){
           $('runSummary').textContent+='\nAutomatic receive failed: '+error.message+' No verified local copy is available. The server result may remain available until deletion or expiry; retry download or delete it.';
           $('bucket_status').textContent='Run completed, but the result was not verified in this browser. No bucket save was attempted.';
           $('runState').textContent='COMPLETE — result not received or verified';$('runState').style.color='#ffd073';
@@ -458,9 +862,44 @@ $('run').onclick = async () => {
           say('Run completed. A verified candidate remains in this page; bucket save needs attention.');
         }
       }
+    }else if(comparisonPlan){
+      try{
+        const received=await receive(job);
+        localResult=new Blob([received.bytes]);localAnalysis=received.analysis;pairedAnalysisPending=false;context.localVerified=true;renderAnalysisPanel();buttons();
+        runResultContext=context;
+        const acknowledgment=await acknowledge(job,received);
+        if(acknowledgment.deleted!==true)throw Error('Frozen comparison result was verified, but server deletion was not confirmed. No next comparison run was started.');
+        if(runReceipt)runReceipt.delivery={received_and_hash_verified:true,server_copy_deleted:true};
+        job=null;buttons();await addFrozenEvaluation();
+      }catch(error){
+        if(retainVerifiedPrimary(error)){
+          $('runState').textContent='COMPLETE — primary network verified; analysis pending';$('runState').style.color='#ffd073';
+          $('runSummary').textContent='The primary network was verified and remains available locally. Paired analysis is pending; no acknowledgment was sent and the comparison stopped. Retry Download result while the server result remains available.';
+          say('Primary network verified. Paired analysis is pending; comparison stopped until the result pair is verified.');
+        }else{
+          comparisonPlan=null;
+          $('evaluationStatus').textContent='Comparison stopped: '+error.message+' No later policy was run.';
+          throw error;
+        }
+      }
     }
   } catch (error) {
+    if(retainVerifiedPrimary(error)){
+      $('runState').textContent='COMPLETE — primary network verified; analysis pending';$('runState').style.color='#ffd073';
+      $('runSummary').textContent='The primary network was verified and is available to save locally. Its paired analysis is still pending, so no receipt, analysis, acknowledgment or bucket save is available. Retry Download result while the server result remains available.';
+      say('Primary network verified. Analysis is pending; retry the paired download before using the run report or saving a bundle.');
+      clearInterval(progress);return;
+    }
     clearInterval(progress);
+    if(comparisonAttempt&&comparisonRows.length){
+      comparisonPlan=null;
+      $('runState').textContent='COMPARISON STOPPED — completed results retained';
+      $('runState').style.color='#ffd073';
+      $('evaluationStatus').textContent='Comparison stopped before '+String(comparisonRole??'the next policy').replaceAll('_',' ')+' completed: '+displayError(error)+' Earlier verified results remain in the table.';
+      $('runSummary').textContent='Completed evaluations retained: '+comparisonRows.length+'\nThe current policy did not produce a fully verified result. Earlier comparison rows remain valid and available.\n'+displayError(error);
+      say('Comparison stopped. Earlier verified results remain in the table. '+displayError(error));
+      return;
+    }
     $('runState').textContent='ERROR — no successful result confirmed';
     $('runState').style.color='#ffb5a2';
     const quotaRejected=isGpuQuotaError(error)||String(error?.message??'').startsWith('GPU allowance is exhausted for this request.');
@@ -469,19 +908,22 @@ $('run').onclick = async () => {
       : 'No downloadable result was received. A connection error does not prove the server stopped.');
     say(displayError(error));
   }
-  finally {clearInterval(progress);busy=false;$('keepServer').checked=false;buttons();}
+  finally {clearInterval(progress);busy=false;$('keepServer').checked=false;buttons();if(comparisonPlan)launchNextComparison();}
 };
 $('download').onclick = async () => {
   busy=true; buttons();
   try {
-    const {bytes,receipt}=await receive(job);
+    const received=await receive(job);
     // The browser has the complete validated result. Disk-save success cannot be observed.
-    localResult=new Blob([bytes]); saveLocal();
-    const acknowledgment=await acknowledge(job,receipt);
+    localResult=new Blob([received.bytes]);localAnalysis=received.analysis;pairedAnalysisPending=false;renderAnalysisPanel();saveLocal();if(localAnalysis?.mode==='evaluate')await addFrozenEvaluation();
+    const acknowledgment=await acknowledge(job,received);
     if(runReceipt)runReceipt.delivery={received_and_hash_verified:true,server_copy_deleted:acknowledgment.deleted===true};
     if (acknowledgment.deleted) { $('runState').textContent='COMPLETE — result received; server copy deleted'; job=null; say('Result received by browser. Server result deleted. Save your local download; server retrieval is no longer available.'); }
     else say('Result received by browser. The server copy is available for another download until its five-minute deadline; use Delete now to remove it sooner.');
-  } catch (error) { say(error.message+' If receipt acknowledgment failed, use Delete now; automatic expiry still applies.'); }
+  } catch (error) {
+    if(retainVerifiedPrimary(error))say('Primary network verified and saved locally. The analysis did not verify, so the job remains available; retry Download result. No acknowledgment was sent.');
+    else say(error.message+' If receipt acknowledgment failed, use Delete now; automatic expiry still applies.');
+  }
   finally {busy=false; buttons();}
 };
 $('erase').onclick=async()=>{
@@ -504,7 +946,7 @@ if($('batch_start')){
       await encoded(original); // Reject missing/oversize inputs before dispatch.
       const backend=$('backend').value,autosaveSnapshot=bucketToken&&$('bucket_autosave')?.checked?bucketSnapshot():null;
       busy=true;batchActive=true;batchStopRequested=false;batchReceipt=null;buttons();
-      localResult=null;
+      localResult=null;localAnalysis=null;pairedAnalysisPending=false;
       $('batch_history').replaceChildren();
       $('batches_feedback').textContent='';
       $('runState').textContent='BATCH RUNNING — completion not yet confirmed';
@@ -514,12 +956,13 @@ if($('batch_start')){
         $('batch_status').textContent='RUNNING · '+plan.name+' · step '+(i+1)+' / '+plan.runs.length+' · '+plan.runs[i].slot;
         const inputHash=await sha(await source.arrayBuffer());
         job=await submit({track,network:await encoded(source),settings,backend,automatic:true});
-        const stepJob=job,{bytes,receipt}=await receive(job);
-        localResult=new Blob([bytes]);showDetails(job.report);
-        const report=stepJob.report,stepRunReceipt={version:1,state:'completed',build:report?.build??appBuild,backend,output_sha256:stepJob.sha256,report};
-        const stepContext={trackInfo,trackBytes,inputNetworkSha256:inputHash,autosaveSnapshot};
+        const stepJob=job,report=stepJob.report,stepRunReceipt={version:1,state:'completed',build:report?.build??appBuild,backend,output_sha256:stepJob.sha256,report};
+        let received;
+        try{received=await receive(job);}catch(error){if(retainVerifiedPrimary(error)){runReceipt=stepRunReceipt;runResultContext={trackInfo,trackBytes,inputNetworkSha256:inputHash,autosaveSnapshot};}throw error;}
+        localResult=new Blob([received.bytes]);localAnalysis=received.analysis;pairedAnalysisPending=false;renderAnalysisPanel();showDetails(job.report);
+        const stepContext={trackInfo,trackBytes,inputNetworkSha256:inputHash,autosaveSnapshot,analysisArchiveBytes:received.analysisBytes};
         runReceipt=stepRunReceipt;runResultContext=stepContext;runReceipt.delivery={received_and_hash_verified:true,server_copy_deleted:false};
-        const ack=await acknowledge(job,receipt);
+        const ack=await acknowledge(job,received);
         if(!ack.deleted)throw Error('Intermediate deletion was not confirmed; batch stopped');
         runReceipt.delivery.server_copy_deleted=true;
         const summary={backend,input_network_sha256:inputHash,output_sha256:stepJob.sha256,server_result_deleted:true,report};
@@ -544,6 +987,7 @@ if($('batch_start')){
       $('runSummary').textContent='Backend: '+backend.toUpperCase()+'\nCompleted steps: '+history.length+'\nUse Save received result again for the last candidate. A completed batch does not establish improved driving.';
       say('Batch results are in browser memory only; no server result remains for completed steps.');
     }catch(error){
+      retainVerifiedPrimary(error);
       if(failedCandidateStep&&!history.some(step=>step.step===failedCandidateStep.step)){
         const failed={...failedCandidateStep,autosave:'failed'};history.push(failed);
         const line=document.createElement('p');line.textContent='Step '+failed.step+' · '+failed.slot+' · '+failed.name+' · result received and server copy deleted · bucket save not confirmed';$('batch_history').append(line);
@@ -615,7 +1059,8 @@ if($('run_export'))$('run_export').onclick=()=>{
   const a=document.createElement('a');a.href=url;a.download='ald-run-receipt.json';a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
 };
 function activeCleanReceipt(){return cleanRunReceipt(runReceipt)||cleanRunReceipt(portableReceipt);}
-function downloadTextFile(text,name,type){const url=URL.createObjectURL(new Blob([text],{type}));const a=document.createElement('a');a.href=url;a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);}
+function downloadBytes(bytes,name,type){const url=URL.createObjectURL(new Blob([bytes],{type}));const a=document.createElement('a');a.href=url;a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);}
+function downloadTextFile(text,name,type){downloadBytes(text,name,type);}
 function formatPlayerReport(receipt){
   const r=receipt.report,metric=value=>typeof value==='number'?String(value):'Not reported';
   const lines=['ALD driving run report','',`Build: ${receipt.build_id}`,`Backend: ${receipt.backend}`,`Vehicle: ${r.vehicle_name} (Type ${r.vehicle_type})`,`Generations: ${r.generations_completed} / ${r.generations_requested}`,`Population: ${r.population}`,`Elapsed seconds: ${metric(r.elapsed_seconds)}`,`Final-generation population best score: ${metric(r.best_score)}`,`Final-generation population mean score: ${metric(r.mean_score)}`,`Best completed lap observed during this run (may be another car): ${r.best_lap_seconds===null?'None':metric(r.best_lap_seconds)+' s'}`,`Cars completing a lap in the final generation: ${r.lapped_cars===null?'Not reported':r.lapped_cars}`,`Simulated ticks: ${r.simulated_ticks}`,`Input network SHA-256: ${r.inputs.network_sha256}`,`Track SHA-256: ${r.inputs.track_sha256}`,`Output network SHA-256: ${receipt.output_sha256}`,'','Configured training settings:',JSON.stringify(r.settings,null,2),'','Reward weights are configured values; per-reward contribution is not reported by the engine.'];
@@ -661,21 +1106,35 @@ function cleanRunReceipt(source){
   try{
     bundleExact(report.inputs,['track_sha256','network_sha256']);
     if(!/^[a-f0-9]{64}$/.test(report.inputs.track_sha256)||!/^[a-f0-9]{64}$/.test(report.inputs.network_sha256))return null;
-    bundleExact(report.settings,Object.keys(window.RecipeLibrary.defaults));
-    const settings=window.RecipeLibrary.settings(report.settings),history=cleanRunHistory(report.history);
+    const recipeSettings={...report.settings},sourceMode=recipeSettings.mode,sourceCleanMinLaps=recipeSettings.clean_min_laps;delete recipeSettings.mode;delete recipeSettings.clean_min_laps;
+    bundleExact(recipeSettings,Object.keys(window.RecipeLibrary.defaults));
+    const analysisSummary=report.analysis_summary?validateAnalysisSummary(report.analysis_summary):null,mode=analysisSummary?.mode??sourceMode;
+    const cleanMinLaps=analysisSummary?.conditions.clean_min_laps??sourceCleanMinLaps??2;
+    if((sourceMode!==undefined&&!['train','evaluate'].includes(sourceMode))||(analysisSummary&&sourceMode!==undefined&&sourceMode!==analysisSummary.mode)||
+       (sourceCleanMinLaps!==undefined&&(!Number.isInteger(sourceCleanMinLaps)||sourceCleanMinLaps<1||sourceCleanMinLaps>100))||
+       (analysisSummary&&sourceCleanMinLaps!==undefined&&sourceCleanMinLaps!==analysisSummary.conditions.clean_min_laps)||!Number.isInteger(cleanMinLaps)||cleanMinLaps<1||cleanMinLaps>100)return null;
+    let settings;
+    if(mode==='evaluate'){
+      if(recipeSettings.population!==1||recipeSettings.generations!==1||recipeSettings.mutation!==0||recipeSettings.mutation_end!==0||recipeSettings.schedule!=='fixed'||recipeSettings.selection!=='best'||recipeSettings.parents!==1||recipeSettings.elite!==0||recipeSettings.crossover!=='none'||recipeSettings.decay!==0||recipeSettings.adaptive_mutation!==false)return null;
+      const checked=window.RecipeLibrary.settings({...recipeSettings,mutation:0.01,mutation_end:0.01});
+      settings={...checked,mutation:0,mutation_end:0};
+    }else settings=window.RecipeLibrary.settings(recipeSettings);
+    const history=cleanRunHistory(report.history);
+    settings.mode=mode??'train';settings.clean_min_laps=cleanMinLaps;
     if(report.population!==settings.population||report.generations_requested!==settings.generations||report.requested_ticks!==settings.ticks||(history&&history.length!==report.generations_completed))return null;
     return {version:1,kind:'run',state:'completed',build_id:buildId,backend:source.backend,output_sha256:source.output_sha256,
       report:{vehicle_type:report.vehicle_type,vehicle_name:report.vehicle_name,generations_completed:report.generations_completed,
         generations_requested:report.generations_requested,population:report.population,elapsed_seconds:report.elapsed_seconds,
         best_score:report.best_score,mean_score:report.mean_score,best_lap_seconds:report.best_lap_seconds,lapped_cars:report.lapped_cars,
         simulated_ticks:report.simulated_ticks,requested_ticks:report.requested_ticks,candidate_validated:true,
-        execution_backend:report.execution_backend,inputs:{track_sha256:report.inputs.track_sha256,network_sha256:report.inputs.network_sha256},settings,...(history?{history}:{})}};
+        execution_backend:report.execution_backend,inputs:{track_sha256:report.inputs.track_sha256,network_sha256:report.inputs.network_sha256},settings,...(history?{history}:{}),...(analysisSummary?{analysis_summary:analysisSummary}:{})}};
   }catch{return null;}
 }
 function validatePortableReceipt(receipt,network,track){
   bundleExact(receipt,['version','kind','state','build_id','backend','output_sha256','report']);
   const report=receipt.report,reportKeys=['vehicle_type','vehicle_name','generations_completed','generations_requested','population','elapsed_seconds','best_score','mean_score','best_lap_seconds','lapped_cars','simulated_ticks','requested_ticks','candidate_validated','execution_backend','inputs','settings'];
   if(Object.hasOwn(report,'history'))reportKeys.push('history');
+  if(Object.hasOwn(report,'analysis_summary'))reportKeys.push('analysis_summary');
   bundleExact(report,reportKeys);
   const clean=cleanRunReceipt(receipt);
   if(receipt.version!==1||receipt.kind!=='run'||receipt.state!=='completed'||!clean)throw Error('Run receipt failed its allowlist or value checks');
@@ -706,9 +1165,10 @@ async function validateBundleTrack(track){
   return file;
 }
 async function buildPortableBundle(){
+  if(pairedAnalysisPending)throw Error('The paired analysis is still pending; retry the server download before exporting a bundle');
   const api=window.PortableBundle;if(!api)throw Error('Portable bundle support is unavailable');
-  const inputNetwork=networkSource(),selected=inputNetwork||localResult;if(!selected)throw Error('Choose or download a network/result first');
-  const kind=inputNetwork?'input':'result',networkBytes=new Uint8Array(await selected.arrayBuffer());
+  const inputNetwork=networkSource(),winner=selectedWinner&&localAnalysis?.winnerNetworks?.[selectedWinner],selected=winner?new Blob([winner.bytes]):inputNetwork||localResult;if(!selected)throw Error('Choose or download a network/result first');
+  const kind=winner||!inputNetwork?'result':'input',networkBytes=new Uint8Array(await selected.arrayBuffer());
   await validateNetworkBytes(networkBytes);
   const network=await api.artifact('evolution',kind,networkBytes),artifacts={selected_network:network};
   let selectedTrack=null,trackInfo=null;
@@ -724,18 +1184,23 @@ async function buildPortableBundle(){
   if($('bundle_recipe').checked){
     const recipe=window.getPortableRecipe?.();if(recipe)artifacts.selected_recipe={version:1,slot:recipe.slot,name:recipe.name,settings:window.RecipeLibrary.settings(recipe.settings)};
   }
-  let note='';
+  let note='',attachedRunReceipt=false;
   const receiptSource=runReceipt||portableReceipt;
   if($('bundle_receipt').checked&&receiptSource){
     const candidate=cleanRunReceipt(receiptSource);
-    const matches=candidate&&((kind==='result'&&candidate.output_sha256===network.sha256)||(kind==='input'&&candidate.report.inputs.network_sha256===network.sha256));
-    if(matches&&(!trackInfo||trackInfo.source!=='builtin'&&trackInfo.source!=='upload'||!selectedTrack||candidate.report.inputs.track_sha256===selectedTrack.sha256))artifacts.run_receipt=candidate;
+    const matches=candidate&&((kind==='result'&&candidate.output_sha256===network.sha256)||(kind==='input'&&candidate.report.inputs.network_sha256===network.sha256)||(winner&&localAnalysis?.summary?.winners?.[selectedWinner]?.artifact?.sha256===network.sha256));
+    if(matches&&(!trackInfo||trackInfo.source!=='builtin'&&trackInfo.source!=='upload'||!selectedTrack||candidate.report.inputs.track_sha256===selectedTrack.sha256)){artifacts.run_receipt=candidate;attachedRunReceipt=true;}
     else note=' The latest run receipt did not match this selected network/track and was omitted.';
   }
+  if(localAnalysis?.archiveBytes&&(kind==='result'||winner)){
+    if(attachedRunReceipt)artifacts.analysis_archive=await api.analysisSlot(localAnalysis.archiveBytes);
+    else note+=' The analysis archive was omitted because its matching run receipt is not included.';
+  }
   const text=await api.pack(artifacts);
   return {text,note};
 }
 async function buildRunResultBundle(resultBlob,sourceReceipt,context){
+  if(pairedAnalysisPending)throw Error('The paired analysis is still pending; retry the server download before saving this run');
   if(!(resultBlob instanceof Blob)||!sourceReceipt||!context?.trackBytes)throw Error('The completed run data is not available for a verified bundle');
   const networkBytes=new Uint8Array(await resultBlob.arrayBuffer()),trackBytes=context.trackBytes;
   await validateNetworkBytes(networkBytes);
@@ -748,7 +1213,14 @@ async function buildRunResultBundle(resultBlob,sourceReceipt,context){
   if(!receipt?.report?.history?.length)throw Error('The completed run has no validated generation history to save');
   if(receipt.output_sha256!==network.sha256||receipt.report.inputs.network_sha256!==context.inputNetworkSha256||receipt.report.inputs.track_sha256!==track.sha256)throw Error('The saved run log does not match the verified network and track bytes');
   validatePortableReceipt(receipt,network,track);
-  const text=await api.pack({selected_network:network,selected_track:track,run_receipt:receipt});
+  const artifacts={selected_network:network,selected_track:track,run_receipt:receipt};
+  if(localAnalysis?.archiveBytes){
+    if(!receipt.report.analysis_summary)throw Error('The analysis archive cannot be saved without its matching validated summary');
+    if(localAnalysis.mode==='train'&&localAnalysis.winnerNetworks?.fitness?.sha256!==network.sha256)throw Error('The primary network does not match the archived fitness winner');
+    if(localAnalysis.mode==='evaluate'&&localAnalysis.summary.conditions.network_sha256!==network.sha256)throw Error('The frozen result does not match the submitted policy');
+    artifacts.analysis_archive=await api.analysisSlot(localAnalysis.archiveBytes);
+  }
+  const text=await api.pack(artifacts);
   return {text,receipt,network,track};
 }
 async function saveVerifiedRunToBucket(snapshot,context){
@@ -762,12 +1234,13 @@ async function saveVerifiedRunToBucket(snapshot,context){
 }
 async function receiveAndAutosave(currentJob,snapshot,context){
   const received=await receive(currentJob);
-  localResult=new Blob([received.bytes]);context.localVerified=true;buttons();
-  const acknowledgment=await acknowledge(currentJob,received.receipt);
+  localResult=new Blob([received.bytes]);localAnalysis=received.analysis;context.analysisArchiveBytes=received.analysisBytes;context.localVerified=true;renderAnalysisPanel();buttons();
+  const acknowledgment=await acknowledge(currentJob,received);
   if(acknowledgment.deleted!==true)throw Error('Candidate was verified, but server deletion was not confirmed; the bucket save was skipped. Download or delete the server result manually.');
   context.serverDeleted=true;
   if(runReceipt)runReceipt.delivery={received_and_hash_verified:true,server_copy_deleted:true};
   if(job===currentJob)job=null;buttons();
+  if(localAnalysis?.mode==='evaluate')await addFrozenEvaluation();
   const outcome=await saveVerifiedRunToBucket(snapshot,context);context.bucketSaveConfirmed=true;return outcome;
 }
 async function exportPortableBundle(){
@@ -779,9 +1252,18 @@ if($('bundle_export'))$('bundle_export').onclick=async()=>{
   try{await exportPortableBundle();}catch(error){bundleMessage('Bundle not exported: '+error.message);}
 };
 async function preparePortableText(text){
-  if(new TextEncoder().encode(text).byteLength>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 8 MiB');
+  if(new TextEncoder().encode(text).byteLength>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 48 MiB');
   const parsed=await window.PortableBundle.parse(text);
   await validateNetworkBytes(parsed.network.bytes);
+  if(parsed.analysisArchive){
+    if(!parsed.receipt?.report?.analysis_summary)throw Error('Version 2 analysis bundles need their matching sanitized run summary');
+    parsed.analysis=await parseRunAnalysisArchive(parsed.analysisArchive.bytes,{size:parsed.analysisArchive.bytes.byteLength,sha256:parsed.analysisArchive.sha256,format:parsed.analysisArchive.format},parsed.receipt.report.analysis_summary);
+    const summary=parsed.analysis.summary,selectedHash=parsed.network.sha256,fitnessHash=summary.winners.fitness.status==='available'?summary.winners.fitness.artifact.sha256:null;
+    const selectedIsWinner=Object.values(parsed.analysis.winnerNetworks).some(w=>w.sha256===selectedHash);
+    if(summary.mode==='evaluate'&&selectedHash!==summary.conditions.network_sha256)throw Error('Frozen evaluation bundle network does not match its unchanged input');
+    if(summary.mode==='train'&&selectedHash!==fitnessHash&&!selectedIsWinner)throw Error('Selected network is not the primary result or a verified winner from this analysis');
+    if(parsed.receipt.output_sha256!==fitnessHash&&summary.mode==='train')throw Error('Run receipt output does not match the fitness leader in its analysis');
+  }
   if(parsed.track){
     if(parsed.track.metadata.source==='builtin'){
       const entry=trackLibrary?.entries().find(e=>e.id===parsed.track.metadata.track_id);
@@ -790,7 +1272,14 @@ async function preparePortableText(text){
     parsed.track.file=await validateBundleTrack(parsed.track);
   }
   if(parsed.recipe){bundleExact(parsed.recipe.settings,Object.keys(window.RecipeLibrary.defaults));parsed.recipe.settings=window.RecipeLibrary.settings(parsed.recipe.settings);}
-  if(parsed.receipt)parsed.receipt=validatePortableReceipt(parsed.receipt,parsed.network,parsed.track?.metadata);
+  if(parsed.receipt){
+    if(parsed.analysis){
+      const clean=cleanRunReceipt(parsed.receipt);if(!clean)throw Error('Run receipt failed its allowlist or value checks');
+      if(parsed.receipt.report.inputs.track_sha256!==parsed.track?.metadata?.sha256&&parsed.track)throw Error('Run receipt does not describe the bundled track');
+      if(parsed.receipt.report.analysis_summary?.conditions?.network_sha256!==parsed.receipt.report.inputs.network_sha256)throw Error('Analysis summary does not describe the receipt input');
+      parsed.receipt=clean;
+    }else parsed.receipt=validatePortableReceipt(parsed.receipt,parsed.network,parsed.track?.metadata);
+  }
   let trackTransfer=null;
   if(parsed.track?.metadata.source==='upload'){
     if(typeof DataTransfer!=='function')throw Error('This browser cannot stage an uploaded track; no bundle data was applied');
@@ -812,6 +1301,7 @@ async function applyPreparedPortable(prepared,{isCurrent=null}={}){
   window.TrainingClient.useNetwork(networkFile);
   if(parsed.recipe)window.stagePortableRecipe(parsed.recipe);
   portableReceipt=parsed.receipt||null;
+  localAnalysis=parsed.analysis||null;selectedWinner=null;renderAnalysisPanel();
   $('bundle_receipt_download').disabled=!portableReceipt;
   bundleMessage('Bundle restored in this page only. Network and optional track/recipe are staged; no run started and no browser storage or server was changed.'+(portableReceipt?' Sanitized receipt is available for separate download.':''));
   buttons();
@@ -827,7 +1317,7 @@ if($('bundle_import'))$('bundle_import').onchange=async()=>{
   try{
     if(bundleRestoring||busy||job)throw Error('Finish the active run before restoring a bundle');
     restoreId=++bundleRestoreId;bundleRestoring=true;buttons();
-    if(file.size>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 8 MiB');
+    if(file.size>window.PortableBundle.LIMITS.bundle)throw Error('Portable bundle exceeds 48 MiB');
     await restorePortableText(await file.text(),{lockHeld:true});
   }catch(error){bundleMessage('Bundle not restored: '+error.message+'. The existing selections were left unchanged.');}
   finally{if(restoreId===bundleRestoreId)bundleRestoring=false;buttons();input.value='';}

delivery.py

@@ -16,6 +16,32 @@ from pydantic import BaseModel, Field
 
 class Unavailable(Exception): pass
 class CapacityExceeded(Exception): pass
+class InvalidAnalysisOutput(Exception): pass
+
+MAX_PRIMARY_BYTES = 4 * 1024 * 1024
+MAX_ANALYSIS_BYTES = 32 * 1024 * 1024
+
+
+def publish_worker_result(store, data, report, automatic=True, *, require_analysis=False):
+    """Remove private worker artifacts before returning the public run report."""
+    if not isinstance(report, dict):
+        if require_analysis:
+            raise InvalidAnalysisOutput()
+        return store.publish(data, automatic), report
+    missing = object()
+    private_files = report.pop('_analysis_files', missing)
+    archive = None
+    if private_files is missing:
+        if require_analysis:
+            raise InvalidAnalysisOutput()
+    else:
+        try:
+            from portable_bundle import BundleError, make_analysis_archive
+            archive = make_analysis_archive(
+                private_files, primary=data, analysis_summary=report.get('analysis_summary'))
+        except BundleError:
+            raise InvalidAnalysisOutput() from None
+    return store.publish(data, automatic, analysis=archive), report
 
 class ResultStore:
     def __init__(self, clock=time.monotonic, wall_clock=time.time, max_bytes=64*1024*1024):
@@ -26,12 +52,17 @@ class ResultStore:
 
     @property
     def retained_bytes(self):
-        with self.lock: return sum(len(j['data']) for j in self.jobs.values())
+        with self.lock:
+            return sum(len(j['data']) + (len(j['analysis']) if j['analysis'] is not None else 0)
+                       for j in self.jobs.values())
 
     def _delete(self, ident):
         record = self.jobs.pop(ident)
-        record['data'][:] = b'\0'*len(record['data'])
-        record['data'].clear()
+        for name in ('data', 'analysis'):
+            payload = record[name]
+            if payload is not None:
+                payload[:] = b'\0' * len(payload)
+                payload.clear()
 
     def expire(self):
         with self.lock:
@@ -42,19 +73,28 @@ class ResultStore:
         with self.lock:
             for ident in list(self.jobs): self._delete(ident)
 
-    def publish(self, data, automatic=True):
-        if not isinstance(data, bytes) or not data or len(data)>4*1024*1024:
+    def publish(self, data, automatic=True, analysis=None):
+        if (not isinstance(data, bytes) or not data or len(data) > MAX_PRIMARY_BYTES
+                or (analysis is not None and (not isinstance(analysis, bytes) or not analysis
+                    or len(analysis) > MAX_ANALYSIS_BYTES))):
             raise CapacityExceeded()
+        retained = len(data) + (len(analysis) if analysis is not None else 0)
         with self.lock:
             self.expire()
-            if len(self.jobs)>=16 or self.retained_bytes+len(data)>self.max_bytes:
+            if len(self.jobs) >= 16 or self.retained_bytes + retained > self.max_bytes:
                 raise CapacityExceeded()
             ident, key = secrets.token_urlsafe(24), secrets.token_urlsafe(32)
             expires = self.wall_clock()+300
-            self.jobs[ident] = dict(key=key, data=bytearray(data), automatic=automatic,
-                deadline=self.clock()+300, expires_at=expires, delivered=False, receipt=None)
-            return dict(id=ident,key=key,expires_at=expires,automatic=automatic,
-                        sha256=hashlib.sha256(data).hexdigest(),size=len(data))
+            self.jobs[ident] = dict(key=key, data=bytearray(data),
+                analysis=bytearray(analysis) if analysis is not None else None,
+                automatic=automatic, deadline=self.clock()+300, expires_at=expires,
+                delivered=False, receipt=None, analysis_delivered=False,
+                analysis_receipt=None)
+            published = dict(id=ident,key=key,expires_at=expires,automatic=automatic,
+                sha256=hashlib.sha256(data).hexdigest(),size=len(data))
+            if analysis is not None:
+                published['analysis'] = {'size': len(analysis), 'sha256': hashlib.sha256(analysis).hexdigest()}
+            return published
 
     def _get(self, ident, key):
         self.expire()
@@ -70,15 +110,35 @@ class ResultStore:
     def download(self, ident, key):
         with self.lock:
             r = self._get(ident,key)
-            if r['automatic'] and r['delivered']: raise Unavailable()
+            # Paired results are retryable as a pair until ACK or expiry. Legacy
+            # primary-only automatic deliveries retain their one-attempt behavior.
+            if r['automatic'] and r['delivered'] and r['analysis'] is None: raise Unavailable()
             r['delivered'] = True
-            r['receipt'] = secrets.token_urlsafe(32)
+            if r['receipt'] is None:
+                r['receipt'] = secrets.token_urlsafe(32)
             return bytes(r['data']), r['receipt']
 
-    def acknowledge(self, ident, key, receipt):
+    def download_analysis(self, ident, key):
+        with self.lock:
+            r = self._get(ident,key)
+            if r['analysis'] is None or not r['delivered'] or r['receipt'] is None:
+                raise Unavailable()
+            r['analysis_delivered'] = True
+            if r['analysis_receipt'] is None:
+                r['analysis_receipt'] = secrets.token_urlsafe(32)
+            return bytes(r['analysis']), r['analysis_receipt']
+
+    def acknowledge(self, ident, key, receipt, analysis_receipt=None):
         with self.lock:
             r = self._get(ident,key)
             if not r['receipt'] or not hmac.compare_digest(r['receipt'],receipt): raise Unavailable()
+            if r['analysis'] is not None:
+                if (not r['analysis_delivered'] or not r['analysis_receipt']
+                        or not isinstance(analysis_receipt, str)
+                        or not hmac.compare_digest(r['analysis_receipt'],analysis_receipt)):
+                    raise Unavailable()
+            elif analysis_receipt is not None:
+                raise Unavailable()
             if r['automatic']:
                 self._delete(ident)
                 return dict(deleted=True)
@@ -92,6 +152,7 @@ class ResultStore:
 
 class Acknowledgment(BaseModel):
     receipt: str = Field(min_length=1,max_length=128)
+    analysis_receipt: str | None = Field(default=None,min_length=1,max_length=128)
 
 def create_api(store=None):
     store = store if store is not None else ResultStore()
@@ -140,9 +201,16 @@ def create_api(store=None):
             'Content-Disposition':'attachment; filename="candidate.evolution"',
             'X-Delivery-Receipt':receipt})
 
+    @app.post('/api/jobs/{ident}/analysis/download')
+    def download_analysis(ident:str,x_job_key:str|None=Header(default=None)):
+        data,receipt = call(store.download_analysis,ident,key(x_job_key))
+        return Response(data,media_type='application/gzip',headers={
+            'Content-Disposition':'attachment; filename="analysis.json.gz"',
+            'X-Analysis-Delivery-Receipt':receipt})
+
     @app.post('/api/jobs/{ident}/ack')
     def ack(ident:str,body:Acknowledgment,x_job_key:str|None=Header(default=None)):
-        return call(store.acknowledge,ident,key(x_job_key),body.receipt)
+        return call(store.acknowledge,ident,key(x_job_key),body.receipt,body.analysis_receipt)
 
     @app.delete('/api/jobs/{ident}')
     def delete(ident:str,x_job_key:str|None=Header(default=None)):

index.html

@@ -29,7 +29,7 @@
 })();
 </script>
 <header><div class="eyebrow">AI LEARNS TO DRIVE · TRAINING LAB</div><h1>Train, inspect, repeat.</h1><p class="intro">Pick a track and network, run a bounded training session, and keep your recipes in this browser.</p><details class="about"><summary>About this beta and its data handling</summary><p>Simulator by <a href="https://github.com/Zorro909/driving_sim_rs">Zorro909</a>; interface and hosting by <a href="https://github.com/seeker-cyber-maker/driving_sim_rs">TiGa</a>. Inspired by the <a href="https://store.steampowered.com/app/3312030/AI_Learns_To_Drive/">game by ActivationFunction</a>. Built-in tracks are reconstructed replicas. Star challenges are not evaluated here.</p><p>Uploaded files are used for the requested run. Results are held briefly in application memory and deleted after verified download or expiry. Browser recipes contain settings only. <a href="/policy" target="_blank" rel="noopener">Read the data policy</a>.</p></details><p><a id="feedbackLink" href="https://github.com/seeker-cyber-maker/driving_sim_rs/issues/new" target="_blank" rel="noopener">Report a problem on GitHub</a> · Opens an editable draft and never submits it. Review details before posting; export a run receipt separately if it helps explain the issue.</p><p id="buildLabel" class="hint">Build: connecting…</p></header>
-<nav class="tabs" aria-label="Lab sections"><button data-tab="drive" aria-selected="true">1 · Drive & view</button><button data-tab="training" aria-selected="false">2 · Training runs & presets</button><button data-tab="batch" aria-selected="false">3 · Batches</button><button data-tab="editor" aria-selected="false">4 · Network editor</button></nav><div id="drive" class="pane"><div class="grid"><section class="card"><h2>Simulation</h2><button id="run" disabled>Run training</button><p class="hint">Select or create a network below to enable training. Review settings on tab 2 before running.</p><p>Supports Formula, Rally, Snowmobile and Truck networks. Control outputs follow the original vehicle editor rules. Network shape and supported sensors are bounded by the original game contract.</p>
+<nav class="tabs" aria-label="Lab sections"><button data-tab="drive" aria-selected="true">1 · Drive & view</button><button data-tab="training" aria-selected="false">2 · Training runs & presets</button><button data-tab="batch" aria-selected="false">3 · Batches</button><button data-tab="editor" aria-selected="false">4 · Network editor</button></nav><div id="drive" class="pane"><div class="grid"><section class="card"><h2>Simulation</h2><label for="run_mode">Action</label><select id="run_mode"><option value="train" selected>Train a population</option><option value="evaluate">Frozen evaluation · one policy, unchanged weights</option></select><p id="run_mode_help" class="hint">Training uses the selected recipe. Frozen evaluation runs the selected policy in a fresh car without changing its weights.</p><button id="run" disabled>Run training</button><p class="hint">Select or create a network below to enable training. Review settings on tab 2 before running.</p><p>Supports Formula, Rally, Snowmobile and Truck networks. Control outputs follow the original vehicle editor rules. Network shape and supported sensors are bounded by the original game contract.</p>
 <p id="computeBlock"><label for="backend">Compute</label><select id="backend" disabled><option value="cpu">CPU — no GPU allowance</option><option id="gpuOption" value="gpu" disabled>GPU — uses GPU allowance</option></select></p><p id="backendNote" class="hint">Checking available backends…</p>
 <div id="connectionRecovery" hidden><button id="retry" type="button">Reconnect to app</button><p class="hint">Checks server availability. Does not restart training, sign you in, or reset GPU allowance.</p></div>
 <div id="gpuAccount" aria-label="Optional GPU account"><p><button id="hfSignIn" type="button" disabled>Sign in with HF for account GPU allowance</button><span id="hfAccount" hidden></span> <button id="hfSignOut" type="button" disabled hidden>Disconnect account</button></p><p id="hfIdentity" role="status" class="hint">CPU needs no sign-in. Checking optional GPU account connection…</p>
@@ -44,10 +44,23 @@
 <p><button id="saveLocal" disabled>Download received result (browser only)</button> <button id="forgetLocal" disabled>Discard browser result</button></p>
 <p>The browser keeps the received result in memory until discarded, replaced by a new run, or this page is closed. It is not saved to browser storage.</p>
 <h3 id="runState" role="status" aria-live="polite">READY — no run started</h3>
-<pre id="runSummary" style="white-space:pre-wrap;line-height:1.7" aria-live="polite"></pre><label class="keep-result"><input id="leaderboard_opt_in" type="checkbox"> After a completed lap, check its position against the public Steam leaderboard</label><p class="privacy-note">Optional, read-only check for supported built-in tracks. It sends the track ID and best lap to this app server; Steam receives only a public leaderboard read. No score is submitted. The result is an estimate, not an official rank.</p><p id="leaderboard_status" role="status" aria-live="polite"></p>
+<pre id="runSummary" style="white-space:pre-wrap;line-height:1.7" aria-live="polite"></pre>
+<section id="analysisPanel" hidden aria-labelledby="analysisTitle">
+<h2 id="analysisTitle">Winners and frozen evaluation</h2>
+<p id="analysisStatus" role="status" aria-live="polite">No complete analysis is available yet.</p>
+<div id="winnerTools" hidden>
+<p class="hint">A network can fill more than one winner role. Select roles to compare; duplicate policies run once. Fitness is final-generation population-relative and is not compared across generations or policy evaluations.</p>
+<div class="table-scroll"><table><thead><tr><th>Compare</th><th>Role</th><th>Candidate</th><th>Generation / car</th><th>Selection fitness</th><th>Best lap</th><th>Forward laps</th><th>Physical contacts</th><th>Distance (simulation units)</th><th>Action</th></tr></thead><tbody id="winnerRows"></tbody></table></div>
+<p><label for="winner_continue">Network to continue or save</label><select id="winner_continue"><option value="">Primary fitness result</option></select> <button id="winner_use" type="button">Use selected network</button></p>
+<div class="toolbar"><button id="compare_winners" type="button" disabled>Compare selected winners</button><button id="analysis_download" type="button" disabled>Download full analysis archive</button></div><p class="hint">Comparison starts one frozen evaluation per distinct selected policy, in sequence. It uses the currently selected track, vehicle, tick limit, control rate and collision/idle settings, then holds those conditions fixed for the full comparison.</p>
+<details><summary>Inspect complete measurements for an evaluated car</summary><div class="row"><label for="descriptor_generation">Generation<input id="descriptor_generation" type="number" min="1" value="1"></label><label for="descriptor_car">Car index<input id="descriptor_car" type="number" min="0" value="0"></label></div><button id="descriptor_show" type="button" disabled>Show all descriptors</button><p id="descriptor_status" role="status"></p><div id="descriptor_tables"></div></details>
+</div>
+<div id="evaluationTools" hidden><p id="evaluationStatus" role="status" aria-live="polite"></p><p class="hint">Frozen evaluation does not select winners or compare population-relative fitness. Each comparison row keeps its network hash and must match the same track, vehicle, horizon, control rate, collision/idle rules, backend and engine build.</p><button id="compare_add" type="button">Add this frozen result to comparison</button><div class="table-scroll"><table><thead><tr><th>Policy</th><th>Vehicle</th><th>Track</th><th>Ticks</th><th>Best lap</th><th>Forward laps</th><th>Physical contacts</th><th>Distance (simulation units)</th><th>Comparison</th></tr></thead><tbody id="evaluationRows"></tbody></table></div><button id="compare_clear" type="button">Clear comparison</button></div>
+</section>
+<label class="keep-result"><input id="leaderboard_opt_in" type="checkbox"> After a completed lap, check its position against the public Steam leaderboard</label><p class="privacy-note">Optional, read-only check for supported built-in tracks. It sends the track ID and best lap to this app server; Steam receives only a public leaderboard read. No score is submitted. The result is an estimate, not an official rank.</p><p id="leaderboard_status" role="status" aria-live="polite"></p>
 <p><button id="run_export" disabled>Export run receipt</button> <button id="player_report_download" disabled>Download player report (.txt)</button> <button id="history_csv_download" disabled>Download generation history (.csv)</button></p><p class="hint">Reports use only server-reported run and generation fields. The engine does not report per-reward contribution, so reward weights are shown as configured values only.</p>
 <details id="portableBundle"><summary>Portable bucket bundle</summary><p>Build, export, or restore one validated bundle. Bucket storage is optional. When connected, automatic save is on by default; turn it off here to keep saves manual. Disconnected runs never call bucket storage.</p><label><input id="bundle_track" type="checkbox"> Include the selected track</label><label><input id="bundle_recipe" type="checkbox"> Include the recipe in the selected slot, if saved</label><label><input id="bundle_receipt" type="checkbox"> Include a sanitized receipt for the selected completed result</label><div class="toolbar"><button id="bundle_export" type="button">Export portable bundle</button><label for="bundle_import">Restore portable bundle (.json)<input id="bundle_import" type="file" accept=".json,application/json"></label><button id="bundle_receipt_download" type="button" disabled>Download staged receipt</button></div><p id="bundle_status" role="status" aria-live="polite">No bucket action has been requested.</p>
-<details id="bucketStorage"><summary>Connect to an existing private bucket</summary><p>Bucket storage is optional. Authorizing storage also identifies your account for GPU requests; ordinary GPU sign-in remains available with the basic identity permission. Then enter your existing private bucket ID. Connected runs automatically save by default; uncheck this option to keep run saves manual. No personal token is requested or stored.</p><p id="bucket_scope_notice" class="privacy-note">HF describes the requested <code>write-repos</code> permission as read/write access to your personal repositories. That grant is broader than one selected bucket and is not a bucket-only permission; the app limits its own operations to the bucket you enter. The minimum current scope for bucket read/write has not been confirmed by HF.</p><button id="bucket_authorize" type="button" hidden disabled>Authorize bucket access with HF</button><p id="bucket_auth_unavailable" class="hint" hidden>HF bucket authorization is unavailable for this app. Local bundle export remains available.</p><p id="bucket_auth_status" role="status" aria-live="polite">Checking optional HF bucket authorization…</p><div id="bucketConnectForm" hidden><label for="bucket_id">Private bucket ID</label><input id="bucket_id" type="text" autocomplete="off" placeholder="username/bucket-name" disabled><button id="bucket_connect" type="button" disabled>Connect bucket</button></div><div id="bucketConnected" hidden><p id="bucket_account"></p><label class="keep-result"><input id="bucket_autosave" type="checkbox" checked> Automatically save every verified completed network and run log to this bucket</label><p class="hint">For each completed run, the browser fetches and verifies the network, then confirms server deletion before sending the network and sanitized log to your bucket. If deletion is not confirmed, no save occurs. If bucket saving is not confirmed, the verified local candidate stays available to download or retry; the remote save may have completed. Each batch step saves before the next starts, and a failed save stops the batch.</p><button id="bucket_disconnect" type="button">Disconnect bucket and clear HF authorization</button><div class="toolbar"><button id="bucket_save" type="button" disabled>Save selected bundle</button><button id="bucket_refresh" type="button" disabled>Refresh saved bundles</button></div><label for="bucket_items">Saved bundles from this app</label><select id="bucket_items" size="4" disabled><option value="">Refresh to list saved bundles</option></select><button id="bucket_restore" type="button" disabled>Restore selected bundle</button></div><p id="bucket_status" role="status" aria-live="polite">Not connected. Bucket storage is optional.</p></details></details>
+<details id="bucketStorage"><summary>Connect to an existing private bucket</summary><p>Bucket storage is optional. Authorizing storage also identifies your account for GPU requests; ordinary GPU sign-in remains available with the basic identity permission. Then enter your existing private bucket ID. Connected runs automatically save by default; uncheck this option to keep run saves manual. No personal token is requested or stored.</p><p id="bucket_scope_notice" class="privacy-note">HF describes the requested <code>write-repos</code> permission as read/write access to your personal repositories. That grant is broader than one selected bucket and is not a bucket-only permission; the app limits its own operations to the bucket you enter. The minimum current scope for bucket read/write has not been confirmed by HF.</p><button id="bucket_authorize" type="button" hidden disabled>Authorize bucket access with HF</button><p id="bucket_auth_unavailable" class="hint" hidden>HF bucket authorization is unavailable for this app. Local bundle export remains available.</p><p id="bucket_auth_status" role="status" aria-live="polite">Checking optional HF bucket authorization…</p><div id="bucketConnectForm" hidden><label for="bucket_id">Private bucket ID</label><input id="bucket_id" type="text" autocomplete="off" placeholder="username/bucket-name" disabled><button id="bucket_connect" type="button" disabled>Connect bucket</button></div><div id="bucketConnected" hidden><p id="bucket_account"></p><label class="keep-result"><input id="bucket_autosave" type="checkbox" checked> Automatically save every verified completed network and run log to this bucket</label><p class="hint">For each completed run, the browser fetches and verifies the network, then confirms server deletion before sending the network and sanitized log to your bucket. If deletion is not confirmed, no save occurs. If bucket saving is not confirmed, the verified local candidate stays available to download or retry; the remote save may have completed. Each batch step saves before the next starts, and a failed save stops the batch.</p><button id="bucket_disconnect" type="button">Disconnect bucket and clear HF authorization</button><div class="toolbar"><button id="bucket_save" type="button" disabled>Save selected bundle</button><button id="bucket_refresh" type="button" disabled>Refresh saved bundles</button></div><label for="bucket_items">Saved bundles from this app</label><select id="bucket_items" size="4" disabled><option value="">Refresh to list saved bundles</option></select><button id="bucket_restore" type="button" disabled>Restore selected bundle</button><hr><h3 id="bucketRecipeTitle" tabindex="-1">Recipe library (settings only)</h3><p class="hint">Save and import the validated recipes and batch definitions from this browser. This 32 KB library contains settings only; networks, tracks, run results and access tokens are never included. Import asks before replacing the local recipe library and never starts a run.</p><div class="toolbar"><button id="bucket_recipe_save" type="button" disabled>Save recipe library</button><button id="bucket_recipe_refresh" type="button" disabled>Refresh saved recipe libraries</button></div><label for="bucket_recipe_items">Saved recipe libraries</label><select id="bucket_recipe_items" size="4" disabled><option value="">Refresh to list saved recipe libraries</option></select><button id="bucket_recipe_import" type="button" disabled>Import selected recipe library</button><p id="bucket_recipe_status" role="status" aria-live="polite">No recipe library bucket action requested.</p></div><p id="bucket_status" role="status" aria-live="polite">Not connected. Bucket storage is optional.</p></details></details>
 <p id="deadline"></p><p id="status" role="status">Ready. Inputs remain on this device until you run the test.</p>
 <details><summary>Effective training settings</summary><pre id="effectiveSettings"></pre></details><details><summary>Generation results</summary><pre id="generationHistory"></pre></details><details><summary>Star challenges — not evaluated</summary><p>The current runner has star-challenge reporting. Its evaluator and required statistics have not been ported to HF; no star result is inferred from a completed test.</p></details></section></div>
 </div><section id="training" class="pane" hidden><div class="card"><h2>Training settings</h2><p class="hint">Choose the track on Drive & view. Choose the training settings and reward mix here, then start the run on Drive & view. Recipes and batch sequences are saved in this browser.</p><p><label for="trackPresetTraining">Training track</label><select id="trackPresetTraining" data-track-library disabled><option value="">Upload a custom track</option></select></p><p data-track-status role="status" class="hint">Loading built-in replica tracks…</p><div id="training_controls"><label for="training_ticks">Simulated ticks per generation</label><input id="training_ticks" type="number" min="1" max="18000" value="60"><small>60 ticks = one simulated second. Current preview limit: population × generations × ticks ≤ 4,000,000; execution timeout 25 seconds.</small>
@@ -68,13 +81,13 @@
 <label for="reward_preset">Reward preset</label><select id="reward_preset" disabled><option value="custom">Custom</option><option value="distance">First laps · distance only</option><option value="center">Example mix · center, clearance, collisions</option><option value="clean">Clean driving · distance + collision penalty</option><option value="lap">Lap refinement · best lap only</option></select>
 <div id="rewards"></div><button id="add" disabled>+ Add reward</button><small>Weights −100…+100; absolute shares normalize to 100%. Five distinct metrics maximum. The current vehicle runner accepts these metrics; choose them for the behavior you want to train.</small>
 </details></div>
-<details id="run_settings"><summary>Run settings · timing and elimination</summary><div class="row"><div><label for="control_hz">Decisions per second</label><select id="control_hz" disabled><option>60</option><option>30</option><option>15</option></select></div><div><label for="workers">Parallel simulations</label><select id="workers" disabled><option>1</option><option selected>2</option><option>3</option><option>4</option></select></div></div><small>Physics runs at 60 Hz. CPU jobs can use 1–4 worker threads.</small><div id="seed_group"><label for="seed">Random seed</label><input id="seed" type="number" min="0" max="2147483647" value="42105" disabled></div><label><input id="collision" type="checkbox" disabled> Eliminate on wall contact</label><label><input id="idle" type="checkbox" disabled> Eliminate when stuck</label></details></div><div id="libraries" class="card"><h3>Recipes · A–J · saved in this browser</h3>
+<details id="run_settings"><summary>Run settings · timing and elimination</summary><div class="row"><div><label for="control_hz">Decisions per second</label><select id="control_hz" disabled><option>60</option><option>30</option><option>15</option></select></div><div><label for="workers">Parallel simulations</label><select id="workers" disabled><option>1</option><option selected>2</option><option>3</option><option>4</option></select></div></div><small>Physics runs at 60 Hz. CPU jobs can use 1–4 worker threads.</small><div id="seed_group"><label for="seed">Random seed</label><input id="seed" type="number" min="0" max="2147483647" value="42105" disabled></div><label><input id="collision" type="checkbox" disabled> Eliminate on wall contact</label><label><input id="idle" type="checkbox" disabled> Eliminate when stuck</label><label for="clean_min_laps">Minimum forward laps for a clean-lap winner</label><input id="clean_min_laps" type="number" min="1" max="100" value="2"><small>Winner classification only. Zero physical contacts are required. This does not change your reward recipe.</small></details></div><div id="libraries" class="card"><h3>Recipes · A–J · saved in this browser</h3>
   <p>Each recipe contains the training settings and reward mix. Tracks, networks and results stay out of the recipe library. Saving a recipe sends nothing to the server. Settings are sent when you start a run.</p>
   <div class="row"><label for="recipe_slot">Recipe slot<select id="recipe_slot"><option>A</option><option>B</option><option>C</option><option>D</option><option>E</option><option>F</option><option>G</option><option>H</option><option>I</option><option>J</option></select></label><label for="recipe_name">Recipe name<input id="recipe_name" maxlength="80" value="My recipe"></label></div>
   <button id="recipe_save">Save current settings</button> <button id="recipe_load">Load recipe</button>
-  <p><button id="recipe_export">Export recipe library</button> <label for="recipe_import">Import recipe library (.json)<input id="recipe_import" type="file" accept=".json"></label></p>
+  <p><button id="recipe_export">Export recipe library</button> <label for="recipe_import">Import recipe library (.json)<input id="recipe_import" type="file" accept=".json"></label> <button id="recipe_bucket_nav" type="button">Bucket import / export</button></p>
   <button id="recipe_clear">Clear saved recipes and batches on this device</button><p id="recipe_feedback" role="status" aria-live="polite"></p>
-  <p>Recipes are specific to this browser and site. Clearing site data removes them. Export a backup to move them between the local runner and HF. Browser privacy settings may prevent saving.</p>
+  <p>Recipes are specific to this browser and site. Clearing site data removes them. Export a backup to move them between the local runner and HF, or use the connected private bucket controls on Drive &amp; view. Browser privacy settings may prevent local saving.</p>
   <details><summary>Advanced recipe JSON</summary><textarea id="recipe_draft" rows="12" style="width:100%" aria-label="Recipe settings JSON"></textarea><button id="recipe_apply_draft">Apply JSON to form</button></details></div></section>
 <section id="batch" class="pane" hidden><div class="card"><h2>Training batches · A–J</h2><p>Choose files and CPU/GPU on Drive & view, then start a saved batch here. Up to 20 runs and 4,000,000 vehicle-ticks in total. Recipes freeze at start. Each server result is automatically deleted after verified receipt. The last candidate is kept in browser memory. Stop prevents the next run; the current run finishes.</p><label for="batch_slot">Batch slot</label><select id="batch_slot" disabled><option>A</option><option>B</option><option>C</option><option>D</option><option>E</option><option>F</option><option>G</option><option>H</option><option>I</option><option>J</option></select><label for="batch_name">Display name</label><input id="batch_name" type="text" maxlength="80" value="My curriculum" disabled><label><input id="carry" type="checkbox" checked disabled> Continue from the previous run’s candidate</label><p class="hint">Unchecked: each run starts from the original selected network. Repeated run references are allowed. Recipes freeze when the batch starts.</p><label for="batch_recipe_sequence">Recipe sequence (comma-separated slots)</label><input id="batch_recipe_sequence" value="A" maxlength="300"><label for="batch_add_recipe">Add recipe<select id="batch_add_recipe"><option>A</option><option>B</option><option>C</option><option>D</option><option>E</option><option>F</option><option>G</option><option>H</option><option>I</option><option>J</option></select></label><button id="queue_add" disabled>+ Add run</button><div class="toolbar"><button id="batch_save" disabled>Save batch</button><button id="batch_load" disabled>Load batch</button><button class="primary" id="batch_start" disabled>Start saved batch</button><button id="batch_stop" disabled>Stop after current run</button><button id="batch_export" disabled>Export batch receipt</button></div><div id="batch_status" role="status">No batch selected.</div><div id="batch_history"></div><div id="batches_feedback" role="status" aria-live="polite"></div></div></section>
 <section id="editor" class="pane" hidden><div class="card"><h2>Network editor</h2><p class="hint">An original editor inspired by <a href="https://the-mars-guy.github.io/AI-Learns-To-Drive-Tool/" target="_blank" rel="noopener">Mars’s network creator</a>. Create fresh networks with the selected vehicle’s game-legal controls, or use its largest original-game shape. Loaded networks keep their original vehicle, output order and sensor parameters. Unsupported files can still be inspected without changing the original.</p><div class="toolbar"><label for="editor_file">Load an existing .evolution file</label><input id="editor_file" type="file" accept=".evolution"><button id="editor_import" disabled>Inspect selected network</button><button id="editor_create" disabled>Create fresh network</button><button id="editor_apply" disabled>Use edited network</button><a id="editor_download" hidden download>Download .evolution</a></div><div class="row"><div><label for="editor_name">Network name</label><input id="editor_name" type="text" maxlength="80" value="Fresh network" disabled><label for="editor_vehicle">Vehicle type for fresh networks</label><select id="editor_vehicle" disabled><option value="0">Formula</option><option value="1">Rally</option><option value="2">Snowmobile</option><option value="3">Truck</option></select><small>This selector applies only when you create a fresh network. Imported vehicle type is retained and shown with the current network.</small><label for="editor_preset">Fresh network preset</label><select id="editor_preset" disabled><option id="editor_small_label" value="small">Small starter · 6 inputs, 4 hidden nodes, 5 outputs</option><option id="editor_maximum_label" value="maximum">Largest game network · 20 inputs, 10 × 16 hidden nodes, 5 outputs</option><option value="custom">Custom</option></select><label for="editor_shape">Input and hidden layer sizes</label><input id="editor_shape" type="text" value="6,4" disabled><small id="editor_shape_hint">Enter 1–20 inputs, followed by 0–10 hidden layers of 1–16 nodes. Output width follows the selected controls. Maximum shape: 20 → ten layers of 16 → 5 (2,869 parameters).</small><fieldset id="editor_outputs" disabled><legend id="editor_output_legend">Fresh network outputs</legend><div class="output-options"><label><input id="editor_output_0" type="checkbox" value="0" checked disabled> Steering (0)</label><label><input id="editor_output_1" type="checkbox" value="1" checked disabled> Acceleration (1)</label><label><input id="editor_output_2" type="checkbox" value="2" checked disabled> Handbrake (2)</label><label><input id="editor_output_3" type="checkbox" value="3" checked disabled> Brake (3)</label><label><input id="editor_output_4" type="checkbox" value="4" checked disabled> Boost (4)</label></div><small id="editor_output_hint">Steering and Acceleration are required. Fresh output IDs preserve this order.</small></fieldset></div><div><label for="editor_seed">Initialization seed</label><input id="editor_seed" type="number" min="0" max="2147483647" value="42105" disabled><label><input id="editor_xavier" type="checkbox" checked disabled> Seeded Xavier uniform weights (browser algorithm)</label><label><input id="editor_bias" type="checkbox" disabled> Xavier uniform biases</label><small>Unchecked: zeros. Biases default to zero.</small></div></div><p id="editor_status" role="status">Choose a file or create a fresh network. Editor changes are browser-local until you explicitly start a run.</p><p id="editor_metadata" class="hint"></p><p id="editor_legality" class="hint"></p><details id="editor_history_panel"><summary>Training history · recorded generations</summary><div class="table-scroll"><table><thead><tr><th>Record</th><th>Time</th><th>Mutation</th><th>Best score</th><th>Best lap</th></tr></thead><tbody id="editor_history"></tbody></table></div><details><summary>Full saved training metadata</summary><pre id="editor_stats"></pre></details></details><canvas aria-label="Network architecture preview" id="network_map" width="1100" height="450"></canvas><details id="weight_values"><summary>Individual weight and bias values</summary><div class="table-scroll" style="max-height:420px;overflow:auto"><table><thead><tr><th>Connection / bias</th><th>Value</th></tr></thead><tbody id="editor_parameters"></tbody></table></div></details><details><summary>Weights, biases and input contract</summary><pre id="editor_contract"></pre><label for="editor_json">NeuralNetwork JSON · editable weights and biases</label><textarea id="editor_json" rows="16" style="width:100%;box-sizing:border-box;background:#0c1725;color:#e5edf5" disabled></textarea></details></div></section><script>/* Settings-only recipe contract. Storage is injected; no network or job data. */
@@ -329,6 +342,14 @@
   try{store=api.createStore(window.localStorage);store.load();message('Browser-local library ready.');}
   catch(error){message('Local library unavailable: '+error.message+'. Existing data was not changed.');}
   const read=()=>{if(!store)throw Error('Browser storage unavailable');return store.load();};
+  window.recipeLibraryText=()=>{const text=JSON.stringify(api.validate(read()));if(new TextEncoder().encode(text).byteLength>32768)throw Error('Recipe library exceeds 32 KB');return text;};
+  window.importRecipeLibraryText=async(text,{source='selected file',isCurrent=()=>true}={})=>{
+    const book=api.parse(text);
+    if(!(await window.appConfirm('Replace this browser’s recipe library with '+book.recipes.length+' recipes and '+book.batches.length+' batches from '+source+'? Export a backup first if needed.',{heading:'Import recipe library',confirmLabel:'Replace library'})))return false;
+    if(!isCurrent())throw Error('Bucket connection changed before import; the local recipe library was not changed.');
+    if(!store)throw Error('Browser storage unavailable');store.save(book);
+    message('Imported '+book.recipes.length+' recipes and '+book.batches.length+' batches from '+source+'. No run was started.');return true;
+  };
   window.getBatchPlan=()=>window.BatchTraining.plan(read(),q('batch_slot').value);
   const action=fn=>async()=>{try{await fn();}catch(error){message('Not completed: '+error.message);}};
   q('recipe_apply_draft').onclick=action(()=>{applySettings(JSON.parse(q('recipe_draft').value));q('preset').value='custom';q('reward_preset').value='custom';message('Draft applied to the training form. No run started.');});
@@ -350,10 +371,7 @@
   });
   q('recipe_import').onchange=action(async()=>{
     const input=q('recipe_import'),file=input.files[0];if(!file)return;input.value='';if(file.size>32768)throw Error('Recipe file exceeds 32 KB');
-    const book=api.parse(await file.text());
-    if(!(await window.appConfirm('Replace this browser’s recipe library with '+book.recipes.length+' imported recipes? Export a backup first if needed.',{heading:'Import recipe library',confirmLabel:'Replace library'})))return;
-    if(!store)throw Error('Browser storage unavailable');store.save(book);
-    message('Imported '+book.recipes.length+' recipes locally. No run was started.');q('recipe_import').value='';
+    await window.importRecipeLibraryText(await file.text(),{source:'selected file'});q('recipe_import').value='';
   });
   q('recipe_clear').onclick=action(async()=>{
     if(!(await window.appConfirm('Clear saved recipes and batches for this app on this device? Server run data and downloaded files are unaffected.',{heading:'Clear local recipes and batches',confirmLabel:'Clear local data',danger:true})))return;
@@ -468,7 +486,7 @@
   if(typeof module==='object'&&module.exports)module.exports=factory();
   else root.PortableBundle=factory();
 })(typeof window==='undefined'?globalThis:window,function(){
-  const SCHEMA='ald.portable-bundle',LIMITS={network:4*1024*1024,track:1024*1024,recipe:32768,receipt:524288,bundle:8*1024*1024};
+  const SCHEMA='ald.portable-bundle',LIMITS={network:4*1024*1024,track:1024*1024,recipe:32768,receipt:524288,analysis:32*1024*1024,bundleV1:8*1024*1024,bundle:48*1024*1024};
   const exact=(value,keys)=>{
     if(!value||typeof value!=='object'||Array.isArray(value)||Object.keys(value).sort().join()!==[...keys].sort().join())throw Error('Unexpected portable bundle fields');
   };
@@ -476,7 +494,7 @@
   const sha=async bytes=>Array.from(new Uint8Array(await crypto.subtle.digest('SHA-256',bytes)),b=>b.toString(16).padStart(2,'0')).join('');
   function b64(bytes){let text='';for(let i=0;i<bytes.length;i+=8192)text+=String.fromCharCode(...bytes.subarray(i,i+8192));return btoa(text);}
   function unb64(text){
-    if(typeof text!=='string'||text.length>Math.ceil(LIMITS.network/3)*4+8)throw Error('Invalid portable artifact encoding');
+    if(typeof text!=='string'||text.length>Math.ceil(LIMITS.analysis/3)*4+8)throw Error('Invalid portable artifact encoding');
     let binary;try{binary=atob(text);}catch{throw Error('Invalid portable artifact encoding');}
     const bytes=Uint8Array.from(binary,c=>c.charCodeAt(0));if(b64(bytes)!==text)throw Error('Non-canonical portable artifact encoding');return bytes;
   }
@@ -486,21 +504,25 @@
     if(!data.length||data.byteLength>limit)throw Error(format==='evolution'?'Network exceeds 4 MiB bundle limit':'Track exceeds 1 MiB bundle limit');
     return {format,kind,bytes:data.byteLength,sha256:await sha(data),data_base64:b64(data)};
   }
+  async function analysisSlot(bytes){const data=bytes instanceof Uint8Array?bytes:new Uint8Array(bytes);if(!data.length||data.length>LIMITS.analysis)throw Error('Analysis archive exceeds 32 MiB');return {format:'ald.run-analysis-archive+gzip',bytes:data.length,sha256:await sha(data),data_base64:b64(data)};}
   async function pack(artifacts){
     if(!artifacts||!artifacts.selected_network)throw Error('A selected network is required');
-    const clean={schema:SCHEMA,version:1,artifacts};
-    const text=JSON.stringify(clean,null,2);if(utf8(text).byteLength>LIMITS.bundle)throw Error('Portable bundle exceeds 8 MiB');
+    const version=artifacts.analysis_archive?2:1;
+    if(version===2){const a=artifacts.analysis_archive;exact(a,['format','bytes','sha256','data_base64']);if(a.format!=='ald.run-analysis-archive+gzip'||!Number.isInteger(a.bytes)||a.bytes<1||a.bytes>LIMITS.analysis||!/^[a-f0-9]{64}$/.test(a.sha256))throw Error('Invalid analysis archive slot');const bytes=unb64(a.data_base64);if(bytes.length!==a.bytes||await sha(bytes)!==a.sha256)throw Error('Analysis archive bytes or SHA-256 do not match');}
+    const clean={schema:SCHEMA,version,artifacts};
+    const text=JSON.stringify(clean,null,2);if(utf8(text).byteLength>(version===1?LIMITS.bundleV1:LIMITS.bundle))throw Error('Portable bundle exceeds its version size limit');
     return text;
   }
   async function parse(text){
-    if(typeof text!=='string'||utf8(text).byteLength>LIMITS.bundle)throw Error('Portable bundle exceeds 8 MiB');
+    if(typeof text!=='string'||utf8(text).byteLength>LIMITS.bundle)throw Error('Portable bundle exceeds 48 MiB');
     let bundle;try{bundle=JSON.parse(text);}catch{throw Error('Portable bundle is not valid JSON');}
-    exact(bundle,['schema','version','artifacts']);if(bundle.schema!==SCHEMA||bundle.version!==1)throw Error('Unsupported portable bundle version');
-    const allowed=['selected_network','selected_track','selected_recipe','run_receipt'];
+    exact(bundle,['schema','version','artifacts']);if(bundle.schema!==SCHEMA||![1,2].includes(bundle.version))throw Error('Unsupported portable bundle version');
+    if(bundle.version===1&&utf8(text).byteLength>LIMITS.bundleV1)throw Error('Version 1 portable bundle exceeds 8 MiB');
+    const allowed=['selected_network','selected_track','selected_recipe','run_receipt',...(bundle.version===2?['analysis_archive']:[])];
     if(!bundle.artifacts||typeof bundle.artifacts!=='object'||Array.isArray(bundle.artifacts)||Object.keys(bundle.artifacts).some(k=>!allowed.includes(k))||!bundle.artifacts.selected_network)throw Error('Portable bundle needs a selected network and fixed artifact slots');
     const a=bundle.artifacts,networkMeta=a.selected_network,networkBytes=await checkArtifact(networkMeta,'evolution',['format','kind','bytes','sha256','data_base64'],LIMITS.network);
     if(!['input','result'].includes(networkMeta.kind))throw Error('Invalid selected network kind');
-    let track=null,recipe=null,receipt=null;
+    let track=null,recipe=null,receipt=null,analysisArchive=null;
     if(Object.hasOwn(a,'selected_track')){
       const t=a.selected_track;if(!t||typeof t!=='object')throw Error('Invalid selected track');
       const builtin=t.source==='builtin';
@@ -521,20 +543,34 @@
       const text=JSON.stringify(r);if(utf8(text).byteLength>LIMITS.receipt)throw Error('Run receipt exceeds 512 KiB bundle limit');
       receipt=r;
     }
-    return {bundle,network:{...networkMeta,bytes:networkBytes},track,recipe,receipt};
+    if(Object.hasOwn(a,'analysis_archive')){
+      if(bundle.version!==2)throw Error('Analysis archive requires portable bundle version 2');
+      const x=a.analysis_archive;exact(x,['format','bytes','sha256','data_base64']);if(x.format!=='ald.run-analysis-archive+gzip'||!Number.isInteger(x.bytes)||x.bytes<1||x.bytes>LIMITS.analysis||!/^[a-f0-9]{64}$/.test(x.sha256))throw Error('Invalid analysis archive metadata');
+      const bytes=unb64(x.data_base64);if(bytes.length!==x.bytes||await sha(bytes)!==x.sha256)throw Error('Analysis archive bytes or SHA-256 do not match');analysisArchive={...x,bytes};
+    }
+    return {bundle,network:{...networkMeta,bytes:networkBytes},track,recipe,receipt,analysisArchive};
   }
   async function checkArtifact(value,format,keys,limit){
     exact(value,keys);if(value.format!==format||!Number.isInteger(value.bytes)||value.bytes<1||value.bytes>limit||! /^[a-f0-9]{64}$/.test(value.sha256))throw Error('Invalid '+format+' artifact metadata');
     const bytes=unb64(value.data_base64);if(bytes.byteLength!==value.bytes||await sha(bytes)!==value.sha256)throw Error(format+' bytes or SHA-256 do not match');
     return bytes;
   }
-  return {SCHEMA,LIMITS,sha,artifact,pack,parse};
+  return {SCHEMA,LIMITS,sha,artifact,analysisSlot,pack,parse};
 });</script><script src="/client.js"></script><script src="/hf-auth.js"></script><script>'use strict';
 // Navigation only. Editor and training/storage adapters are separate layers.
 document.querySelectorAll('[data-tab]').forEach(button=>button.addEventListener('click',()=>{
   document.querySelectorAll('.pane').forEach(pane=>pane.hidden=pane.id!==button.dataset.tab);
   document.querySelectorAll('[data-tab]').forEach(tab=>tab.setAttribute('aria-selected',String(tab===button)));
 }));
+document.getElementById('recipe_bucket_nav').addEventListener('click',()=>{
+  document.querySelector('[data-tab="drive"]').click();
+  document.getElementById('portableBundle').open=true;
+  const storage=document.getElementById('bucketStorage');storage.open=true;
+  const connected=document.getElementById('bucketConnected');
+  const recipeTitle=document.getElementById('bucketRecipeTitle');
+  const target=connected&&!connected.hidden&&recipeTitle?recipeTitle:storage.querySelector('summary');
+  target?.scrollIntoView({behavior:'smooth',block:'center'});target?.focus({preventScroll:true});
+});
 </script><script>// Browser-only editor; upload is controlled by the separate training client.
 (() => {
   const q=id=>document.getElementById(id),api=window.NetworkEditor;

native/analysis.patch

@@ -0,0 +1,607 @@
+--- a/src/bin/altd-sim/args.rs
++++ b/src/bin/altd-sim/args.rs
+@@ -290,6 +290,15 @@
+         /// Export the final complete batch fitness leader before reproduction.
+         #[arg(long)]
+         save_final_candidate: bool,
++        /// Record every evaluated car and the three distinct winner roles.
++        #[arg(long)]
++        analysis: bool,
++        /// Evaluate the exact init-network once without initializing an optimizer population.
++        #[arg(long, requires = "init_network")]
++        evaluate_frozen: bool,
++        /// Forward laps required for the zero-physical-contact winner.
++        #[arg(long, default_value_t = 2)]
++        clean_min_laps: u64,
+         /// Stop after a generation whose best total_score reaches this value.
+         #[arg(long)]
+         stop_score_above: Option<f64>,
+--- a/src/bin/altd-sim/main.rs
++++ b/src/bin/altd-sim/main.rs
+@@ -161,6 +161,9 @@
+             batch_count,
+             checkpoint_every,
+             save_final_candidate,
++            analysis,
++            evaluate_frozen,
++            clean_min_laps,
+             resume,
+             eliminate_on_wall,
+             no_eliminate_on_wall,
+@@ -203,6 +206,9 @@
+                 batch_count,
+                 checkpoint_every,
+                 save_final_candidate,
++                analysis,
++                evaluate_frozen,
++                clean_min_laps,
+                 resume,
+                 stop,
+                 eliminate_on_wall: flag(eliminate_on_wall, no_eliminate_on_wall),
+--- a/src/bin/altd-sim/scratch/analysis.rs
++++ b/src/bin/altd-sim/scratch/analysis.rs
+@@ -0,0 +1,253 @@
++//! Read-only generation-boundary observations and immutable winner snapshots.
++use altd_sim::training::{
++    evolution::{reward_descriptors, METRIC_NAMES},
++    TrainingRunner,
++};
++use serde_json::{json, Value};
++use std::{
++    fs::File,
++    io::{BufWriter, Write},
++    path::{Path, PathBuf},
++};
++
++const MAX_DESCRIPTOR_BYTES: usize = 256 * 1024 * 1024;
++
++pub(super) struct Analysis {
++    dir: PathBuf,
++    output: BufWriter<File>,
++    bytes: usize,
++    rows: usize,
++    clean_min_laps: u64,
++    frozen: bool,
++    fitness: Option<Value>,
++    fastest: Option<Value>,
++    clean: Option<Value>,
++    evaluation: Option<Value>,
++}
++
++fn weight_hash(params: &[f64]) -> String {
++    let bytes: Vec<u8> = params.iter().flat_map(|p| p.to_le_bytes()).collect();
++    altd_sim::training::evaluation::sha256(&bytes)
++}
++
++fn eligible(row: &Value, clean_min_laps: Option<u64>) -> bool {
++    row["objectives"]["best_lap_seconds"]
++        .as_f64()
++        .is_some_and(|v| v.is_finite() && v > 0.0)
++        && row["objectives"]["forward_laps"]
++            .as_u64()
++            .is_some_and(|laps| laps >= clean_min_laps.unwrap_or(1))
++        && (clean_min_laps.is_none() || row["objectives"]["physical_contacts"].as_u64() == Some(0))
++}
++
++fn better_lap(row: &Value, previous: Option<&Value>) -> bool {
++    previous.is_none_or(|old| {
++        row["objectives"]["best_lap_seconds"].as_f64().unwrap()
++            < old["objectives"]["best_lap_seconds"].as_f64().unwrap()
++    })
++}
++
++impl Analysis {
++    pub(super) fn new(dir: &Path, clean_min_laps: u64, frozen: bool) -> Self {
++        assert!((1..=100).contains(&clean_min_laps), "clean minimum laps must be 1..100");
++        let dir = dir.join("analysis");
++        std::fs::create_dir_all(dir.join("winners")).expect("analysis directory");
++        let output = BufWriter::new(File::create(dir.join("descriptors.jsonl")).expect("analysis descriptors"));
++        Self {
++            dir,
++            output,
++            bytes: 0,
++            rows: 0,
++            clean_min_laps,
++            frozen,
++            fitness: None,
++            fastest: None,
++            clean: None,
++            evaluation: None,
++        }
++    }
++
++    fn snapshot(&self, role: &str, row: &Value, runner: &TrainingRunner, index: usize, network_data: &Value) {
++        let mut network = runner.agents[index].network.to_json();
++        network["inputs"] = network_data["inputs"].clone();
++        network["outputs"] = network_data["outputs"].clone();
++        network["observation"] = row.clone();
++        std::fs::write(
++            self.dir.join(format!("winners/{role}.json")),
++            serde_json::to_vec(&network).unwrap(),
++        )
++        .expect("immutable selected weight snapshot");
++    }
++
++    pub(super) fn record(&mut self, runner: &TrainingRunner, generation: usize, fitness: &[f64], network_data: &Value) {
++        assert_eq!(fitness.len(), runner.agents.len());
++        let channels = reward_descriptors(&runner.results());
++        assert_eq!(channels.len(), 18);
++        let leader = if self.frozen {
++            0
++        } else {
++            super::runner::final_candidate_leader(fitness)
++        };
++        for (index, agent) in runner.agents.iter().enumerate() {
++            let raw: serde_json::Map<String, Value> = METRIC_NAMES
++                .iter()
++                .zip(agent.stats.metrics())
++                .map(|(name, value)| ((*name).into(), json!(value.filter(|v| v.is_finite()))))
++                .collect();
++            let channel_values: Vec<Value> = channels.iter().map(|c| c["values"][index].clone()).collect();
++            let channel_ranks: Vec<Value> = channels
++                .iter()
++                .map(|c| c["population_relative"][index].clone())
++                .collect();
++            let reasons: Vec<Value> = channels
++                .iter()
++                .map(|column| {
++                    if !column["values"][index].is_null() {
++                        Value::Null
++                    } else if column["metric"] == "best_lap_performance" {
++                        json!("no_completed_lap")
++                    } else if column["type"] == "average" && agent.stats.update_count == 0 {
++                        json!("no_statistics_updates")
++                    } else {
++                        json!("not_observed")
++                    }
++                })
++                .collect();
++            let row = json!({"schema":1, "generation":generation + 1, "car":index,
++                "candidate_id":format!("g{:06}-c{:06}", generation + 1, index),
++                "ticks_elapsed":runner.tick, "stats_update_count":agent.stats.update_count,
++                "raw_metrics":raw, "channels":{"values":channel_values, "population_relative":channel_ranks, "unavailable_reasons":reasons},
++                "selection_fitness":if self.frozen {Value::Null} else {json!(fitness[index])},
++                "objectives":{"best_lap_seconds":agent.stats.best_lap_time.filter(|v| v.is_finite() && *v > 0.0),
++                    "forward_laps":agent.stats.score.lap_count, "physical_contacts":agent.car.collision_count,
++                    "collision_updates":agent.stats.collision_count, "total_actual_distance":agent.stats.total_actual_distance,
++                    "active":agent.car.active},
++                "weights_sha256":weight_hash(&agent.network.params)});
++            let text = serde_json::to_vec(&row).expect("finite descriptor");
++            self.bytes += text.len() + 1;
++            assert!(
++                self.bytes <= MAX_DESCRIPTOR_BYTES,
++                "complete analysis exceeds 256 MiB; no descriptors truncated"
++            );
++            self.output
++                .write_all(&text)
++                .and_then(|_| self.output.write_all(b"\n"))
++                .expect("descriptor write");
++            self.rows += 1;
++            if self.frozen {
++                self.evaluation = Some(row);
++                continue;
++            }
++            // Replacing only on a strictly better lap retains the earliest generation/car tie.
++            if eligible(&row, None) && better_lap(&row, self.fastest.as_ref()) {
++                self.snapshot("fastest_lap", &row, runner, index, network_data);
++                self.fastest = Some(row.clone());
++            }
++            if eligible(&row, Some(self.clean_min_laps)) && better_lap(&row, self.clean.as_ref()) {
++                self.snapshot("clean_laps", &row, runner, index, network_data);
++                self.clean = Some(row.clone());
++            }
++            // Fitness ranks belong to this population. Always overwrite with this generation's leader.
++            if index == leader {
++                self.snapshot("fitness", &row, runner, index, network_data);
++                self.fitness = Some(row);
++            }
++        }
++        self.output.flush().expect("flush complete descriptors before turnover");
++    }
++
++    pub(super) fn finish(mut self) {
++        self.output.flush().expect("flush analysis");
++        let data = json!({"schema":"ald.native-analysis", "version":1, "rows":self.rows,
++            "mode":if self.frozen {"evaluate"} else {"train"}, "clean_min_laps":self.clean_min_laps,
++            "winners":{"fitness":self.fitness, "fastest_lap":self.fastest, "clean_laps":self.clean},
++            "evaluation":self.evaluation, "metric_names":METRIC_NAMES});
++        std::fs::write(self.dir.join("analysis.json"), serde_json::to_vec(&data).unwrap()).expect("analysis summary");
++    }
++}
++
++#[cfg(test)]
++#[path = "../../../../examples/support/generated.rs"]
++mod generated;
++
++#[cfg(test)]
++mod tests {
++    use super::*;
++    fn row(laps: u64, contacts: u64, lap: Option<f64>) -> Value {
++        json!({"objectives":{"forward_laps":laps,"physical_contacts":contacts,"best_lap_seconds":lap}})
++    }
++    #[test]
++    fn distinct_roles_keep_global_laps_but_final_population_fitness_and_old_weights() {
++        use altd_sim::{
++            math::profile::MathProfile,
++            nn::network::Network,
++            track::world::{vector, World},
++            training::{evolution::EvolutionSettings, pyrandom::PyRandom, SensorLayout},
++        };
++        use std::sync::Arc;
++        let scene = generated::scene("formula", 0);
++        let network_data = json!({"inputs":["Speed"], "outputs":["Acceleration"]});
++        let layout = SensorLayout::from_ordered(&json!({"names":["Speed"], "sensors":[{"$type":"speed"}]})).unwrap();
++        let mut runner = TrainingRunner::new(
++            Arc::new(World::from_scene_with(&scene, MathProfile::Proton)),
++            vector(&scene["reset_position"]),
++            scene["reset_rotation"].as_f64().unwrap(),
++            layout,
++            &["Acceleration".into()],
++            EvolutionSettings::default(),
++            PyRandom::new(42),
++            2,
++            0,
++            false,
++            false,
++        );
++        let networks: Vec<_> = (0..3)
++            .map(|i| Network::from_vector(&[1, 1], vec![i as f64, 0.0]))
++            .collect();
++        runner.resume(&networks, 0);
++        for (i, agent) in runner.agents.iter_mut().enumerate() {
++            agent.stats.update_count = 10;
++            agent.stats.best_lap_time = [None, Some(5.0), Some(8.0)][i];
++            agent.stats.score.lap_count = [0, 1, 2][i];
++            // Reward collision updates cannot disqualify a physically clean car.
++            agent.stats.collision_count = if i == 2 { 9 } else { 0 };
++        }
++        let dir = std::env::temp_dir().join(format!("ald-distinct-winners-{}", std::process::id()));
++        std::fs::create_dir(&dir).unwrap();
++        let mut writer = Analysis::new(&dir, 2, false);
++        writer.record(&runner, 0, &[0.9, 0.7, 0.1], &network_data);
++        assert_eq!(writer.clean.as_ref().unwrap()["car"], 2);
++        for (i, agent) in runner.agents.iter_mut().enumerate() {
++            agent.network.params = vec![10.0 + i as f64, 0.0];
++            agent.stats.best_lap_time = [Some(6.0), Some(5.0), None][i];
++            agent.stats.score.lap_count = [2, 2, 0][i];
++            agent.car.collision_count = if i == 0 { 1 } else { 0 };
++        }
++        writer.record(&runner, 1, &[0.0, 0.5, 0.2], &network_data);
++        assert_eq!(writer.fastest.as_ref().unwrap()["generation"], 1);
++        assert_eq!(writer.fastest.as_ref().unwrap()["car"], 1);
++        assert_eq!(writer.clean.as_ref().unwrap()["generation"], 2);
++        assert_eq!(writer.fitness.as_ref().unwrap()["generation"], 2);
++        assert_eq!(writer.fitness.as_ref().unwrap()["selection_fitness"], 0.5);
++        let fastest: Value =
++            serde_json::from_slice(&std::fs::read(dir.join("analysis/winners/fastest_lap.json")).unwrap()).unwrap();
++        assert_eq!(fastest["weights"][0][0][0], 1.0);
++        writer.finish();
++        std::fs::remove_dir_all(dir).unwrap();
++    }
++
++    #[test]
++    fn clean_requires_forward_laps_and_physical_contacts_not_reward_updates() {
++        assert!(!eligible(&row(0, 0, None), None));
++        assert!(eligible(&row(1, 3, Some(10.0)), None));
++        assert!(!eligible(&row(1, 0, Some(10.0)), Some(2)));
++        assert!(!eligible(&row(2, 1, Some(10.0)), Some(2)));
++        assert!(eligible(&row(2, 0, Some(10.0)), Some(2)));
++    }
++    #[test]
++    fn lap_ties_keep_earlier_snapshot_and_rank_fitness_is_not_a_tiebreaker() {
++        let old = row(2, 0, Some(10.0));
++        assert!(!better_lap(&old, Some(&old)));
++        assert!(better_lap(&row(2, 0, Some(9.0)), Some(&old)));
++    }
++}
+--- a/src/bin/altd-sim/scratch/mod.rs
++++ b/src/bin/altd-sim/scratch/mod.rs
+@@ -1,5 +1,6 @@
+ //! Scratch training configuration, checkpoints, and stopping rules.
+ 
++mod analysis;
+ mod checkpoint;
+ mod runner;
+ mod stop;
+@@ -37,6 +38,9 @@
+     pub(super) batch_count: usize,
+     pub(super) checkpoint_every: usize,
+     pub(super) save_final_candidate: bool,
++    pub(super) analysis: bool,
++    pub(super) evaluate_frozen: bool,
++    pub(super) clean_min_laps: u64,
+     pub(super) stop: StopRules,
+     pub(super) eliminate_on_wall: Option<bool>,
+     pub(super) idle_eliminate: Option<bool>,
+--- a/src/bin/altd-sim/scratch/runner.rs
++++ b/src/bin/altd-sim/scratch/runner.rs
+@@ -74,7 +74,7 @@
+         "population, generations, and ticks must be positive"
+     );
+     assert!(
+-        config.mutation_start > 0.0 && config.mutation_end > 0.0,
++        config.evaluate_frozen || (config.mutation_start > 0.0 && config.mutation_end > 0.0),
+         "mutation rates must be positive"
+     );
+ 
+@@ -110,6 +110,15 @@
+         .validate_algorithm()
+         .unwrap_or_else(|e| panic!("settings: {e}"));
+ 
++    assert!(
++        !config.analysis || (track_count_guard(config) && !config.resume && config.init_population.is_none()),
++        "analysis requires a fresh fixed-track run"
++    );
++    assert!(
++        !config.evaluate_frozen
++            || (config.analysis && config.population == 1 && config.generations == 1 && config.checkpoint_every == 0),
++        "frozen evaluation requires analysis, one exact policy, one generation, and no checkpoint turnover"
++    );
+     let dir = &config.out_dir;
+     let best_dir = dir.join("best_laps");
+     std::fs::create_dir_all(&best_dir).unwrap_or_else(|e| panic!("{}: {e}", best_dir.display()));
+@@ -338,7 +347,11 @@
+         );
+         generation as usize
+     } else {
+-        runner.start(seed_network.as_ref().unwrap());
++        if config.evaluate_frozen {
++            runner.resume(&[seed_network.as_ref().unwrap().clone()], 0);
++        } else {
++            runner.start(seed_network.as_ref().unwrap());
++        }
+         std::fs::write(&log_path, "").expect("log file");
+         0
+     };
+@@ -370,6 +383,10 @@
+         started.elapsed().as_secs_f64()
+     );
+ 
++    let frozen_params = config.evaluate_frozen.then(|| runner.agents[0].network.params.clone());
++    let mut analysis = config
++        .analysis
++        .then(|| super::analysis::Analysis::new(dir, config.clean_min_laps, config.evaluate_frozen));
+     let fmt_lap = |lap: Option<f64>| lap.map_or("   -   ".to_string(), |t| format!("{t:7.2}"));
+     let mut stop_state = StopState {
+         best_lap: None,
+@@ -493,6 +510,18 @@
+         }
+         let simulate_seconds = generation_started.elapsed().as_secs_f64();
+         let summary = batch.finish();
++        if let Some(params) = &frozen_params {
++            assert!(
++                params
++                    .iter()
++                    .zip(&runner.agents[0].network.params)
++                    .all(|(a, b)| a.to_bits() == b.to_bits()),
++                "frozen weights changed during evaluation"
++            );
++        }
++        if let Some(writer) = &mut analysis {
++            writer.record(&runner, generation, &summary.fitness, &network_data);
++        }
+         let best_score = summary.mean_scores.iter().copied().fold(f64::NEG_INFINITY, f64::max);
+         let mean_score = py_sum(summary.mean_scores.iter().copied()) / config.population as f64;
+         let mean_lap = (lap_count > 0).then(|| lap_time_sum / lap_count as f64);
+@@ -521,7 +550,7 @@
+         }
+         let last = stop_reason.is_some();
+         let final_checkpoint = last && config.checkpoint_every > 0;
+-        let candidate = if last && config.save_final_candidate {
++        let candidate = if last && config.save_final_candidate && !config.evaluate_frozen {
+             let leader = final_candidate_leader(&summary.fitness);
+             let mut export = runner.agents[leader].network.to_json();
+             export["schema_version"] = json!(1);
+@@ -606,6 +635,9 @@
+             break;
+         }
+     }
++    if let Some(writer) = analysis {
++        writer.finish();
++    }
+     let _ = std::fs::remove_file(dir.join("progress.json"));
+     println!(
+         "done: best lap {} (generation {}), {:.1} h",
+@@ -614,3 +646,7 @@
+         started.elapsed().as_secs_f64() / 3600.0
+     );
+ }
++
++fn track_count_guard(config: &ScratchConfig) -> bool {
++    config.tracks.settings().is_none()
++}
+--- a/src/training/evolution.rs
++++ b/src/training/evolution.rs
+@@ -397,6 +397,42 @@
+         }
+     }
+     result
++}
++
++/// Observe every game reward channel without altering selection or drawing RNG.
++/// The unsigned ranks use the native selection normalization, but missing
++/// measurements remain null instead of exposing selection's zero fallback.
++pub fn reward_descriptors(agents: &[AgentResult]) -> Vec<Value> {
++    let mut channels = Vec::new();
++    for metric in METRIC_NAMES {
++        for kind in ["default", "average"] {
++            if (kind == "default" && AVERAGE_ONLY_METRICS.contains(&metric))
++                || (kind == "average" && !AVERAGE_METRICS.contains(&metric))
++            {
++                continue;
++            }
++            let spec = RewardSpec {
++                metric: metric.into(),
++                weight: 100,
++                kind: kind.into(),
++            };
++            let values: Vec<Option<f64>> = agents
++                .iter()
++                .map(|agent| {
++                    if kind == "average" && agent.update_count == 0 {
++                        None
++                    } else {
++                        agent.value(&spec).filter(|v| v.is_finite())
++                    }
++                })
++                .collect();
++            let ranks = rank_normalize(&values);
++            channels.push(json!({"metric": metric, "type": kind, "values": values,
++                "population_relative": ranks.iter().zip(&values)
++                    .map(|(rank, value)| value.map(|_| *rank)).collect::<Vec<_>>() }));
++        }
++    }
++    channels
+ }
+ 
+ /// The adaptive mutation scale; its log is the C runtime's (.NET Math.Log).
+--- a/tests/winner_analysis.rs
++++ b/tests/winner_analysis.rs
+@@ -0,0 +1,147 @@
++//! Native boundary checks: observations preserve evolution and frozen policies.
++use altd_sim::nn::network::Network;
++use serde_json::{json, Value};
++use std::{fs, path::Path, process::Command};
++#[path = "../examples/support/generated.rs"]
++mod generated;
++fn load(path: impl AsRef<Path>) -> Value {
++    serde_json::from_slice(&fs::read(path).unwrap()).unwrap()
++}
++fn run(root: &Path, name: &str, extra: &[&str]) {
++    let mut command = Command::new(env!("CARGO_BIN_EXE_altd-sim"));
++    command
++        .args([
++            "--threads",
++            "1",
++            "--math-profile",
++            "proton",
++            "train-scratch",
++            "--shape",
++            "20,5",
++            "--population",
++            if extra.contains(&"--evaluate-frozen") { "1" } else { "4" },
++            "--generations",
++            if extra.contains(&"--evaluate-frozen") { "1" } else { "2" },
++            "--ticks",
++            "60",
++            "--mutation-start",
++            "0.2",
++            "--mutation-end",
++            "0.2",
++            "--seed",
++            "42",
++            "--checkpoint-every",
++            "0",
++            "--save-final-candidate",
++            "--no-idle-eliminate",
++            "--no-eliminate-on-wall",
++        ])
++        .arg("--scene")
++        .arg(root.join("scene.json"))
++        .arg("--spawn-trace")
++        .arg(root.join("spawn.json"))
++        .arg("--network")
++        .arg(root.join("seed.json"))
++        .arg("--init-network")
++        .arg(root.join("seed.json"))
++        .arg("--model")
++        .arg(concat!(env!("CARGO_MANIFEST_DIR"), "/assets/models/rally.json"))
++        .arg("--settings")
++        .arg(root.join("settings.json"))
++        .arg("--out-dir")
++        .arg(root.join(name))
++        .args(extra);
++    let output = command.output().unwrap();
++    assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));
++}
++fn workspace(tag: &str) -> std::path::PathBuf {
++    let root = std::env::temp_dir().join(format!("ald-winner-analysis-{}-{tag}", std::process::id()));
++    fs::create_dir(&root).unwrap();
++    let scene = generated::scene("rally", 0);
++    let metadata = generated::network("rally");
++    let mut seed = Network::from_vector(&[20, 5], vec![0.1; 105]).to_json();
++    seed["inputs"] = metadata["inputs"].clone();
++    seed["outputs"] = metadata["outputs"].clone();
++    for (name, value) in [
++        ("scene.json", scene.clone()),
++        ("seed.json", seed),
++        ("spawn.json", json!({"frames":[generated::spawn(&scene)]})),
++        (
++            "settings.json",
++            json!({"selection_algorithm":"best","selection_size":1,"preserve_parents":"on_custom",
++            "preserve_parents_size":1,"weight_decay":0.8,"rewards":[{"metric":"total_actual_distance","weight":100,"type":"default"}]}),
++        ),
++    ] {
++        fs::write(root.join(name), value.to_string()).unwrap();
++    }
++    root
++}
++#[test]
++fn observation_is_rng_neutral_and_final_winner_matches_exact_pre_turnover_parameters() {
++    let root = workspace("neutral");
++    run(&root, "plain", &[]);
++    run(&root, "observed", &["--analysis"]);
++    assert_eq!(
++        load(root.join("plain/candidate.json")),
++        load(root.join("observed/candidate.json"))
++    );
++    let plain: Vec<Value> = fs::read_to_string(root.join("plain/log.jsonl"))
++        .unwrap()
++        .lines()
++        .map(|l| serde_json::from_str(l).unwrap())
++        .collect();
++    let observed: Vec<Value> = fs::read_to_string(root.join("observed/log.jsonl"))
++        .unwrap()
++        .lines()
++        .map(|l| serde_json::from_str(l).unwrap())
++        .collect();
++    for (a, b) in plain.iter().zip(&observed) {
++        for key in [
++            "best_score",
++            "mean_score",
++            "best_fitness",
++            "mean_fitness",
++            "total_metric_values",
++            "simulated_ticks",
++        ] {
++            assert_eq!(a[key], b[key], "{key}");
++        }
++    }
++    let summary = load(root.join("observed/analysis/analysis.json"));
++    assert_eq!(summary["rows"], 8);
++    assert_eq!(summary["winners"]["fitness"]["generation"], 2);
++    let selected = load(root.join("observed/analysis/winners/fitness.json"));
++    let candidate = load(root.join("observed/candidate.json"));
++    assert_eq!(selected["weights"], candidate["weights"]);
++    assert_eq!(selected["biases"], candidate["biases"]);
++    assert!(summary["winners"]["fastest_lap"].is_null());
++    assert!(summary["winners"]["clean_laps"].is_null());
++    let rows: Vec<Value> = fs::read_to_string(root.join("observed/analysis/descriptors.jsonl"))
++        .unwrap()
++        .lines()
++        .map(|l| serde_json::from_str(l).unwrap())
++        .collect();
++    assert_eq!(rows.len(), 8);
++    assert_eq!(rows[0]["raw_metrics"].as_object().unwrap().len(), 14);
++    assert_eq!(rows[0]["channels"]["values"].as_array().unwrap().len(), 18);
++    assert!(rows.iter().any(|row| row == &selected["observation"]));
++    fs::remove_dir_all(root).unwrap();
++}
++#[test]
++fn frozen_evaluation_never_breeds_or_decays_and_has_no_parent_candidate() {
++    let root = workspace("frozen");
++    run(&root, "evaluated", &["--analysis", "--evaluate-frozen"]);
++    let summary = load(root.join("evaluated/analysis/analysis.json"));
++    assert_eq!(summary["rows"], 1);
++    assert!(summary["winners"]["fitness"].is_null());
++    assert!(summary["evaluation"]["selection_fitness"].is_null());
++    let seed = Network::from_game_export(&load(root.join("seed.json")));
++    let bytes: Vec<u8> = seed.params.iter().flat_map(|p| p.to_le_bytes()).collect();
++    assert_eq!(
++        summary["evaluation"]["weights_sha256"],
++        altd_sim::training::evaluation::sha256(&bytes)
++    );
++    assert!(!root.join("evaluated/candidate.json").exists());
++    assert!(!root.join("evaluated/checkpoint.json").exists());
++    fs::remove_dir_all(root).unwrap();
++}

native/build-receipt.json

@@ -0,0 +1,89 @@
+{
+  "schema": "ald-winners-linux-build-v1",
+  "status": "passed",
+  "created_utc": "2026-10-14T04:35:53.223545+00:00",
+  "source": {
+    "upstream_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0",
+    "source_receipt_sha256": "33d09c326e4d6c3ac1d1839e4528c70c06b4ff48138b90f174f434ab685b4b34",
+    "patch_sha256": "56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63",
+    "source_inventory_sha256": "3311905f217e08a927ca73d71db6687aaaf68f01cc2758e4028b92fa703bcebe"
+  },
+  "artifacts": {
+    "cpu/bin/altd-sim": {
+      "path": "cpu/bin/altd-sim",
+      "bytes": 3580296,
+      "sha256": "6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d",
+      "origin_type": "local_linux_build"
+    },
+    "gpu/bin/altd-sim": {
+      "path": "gpu/bin/altd-sim",
+      "bytes": 3580296,
+      "sha256": "6488c7ec651701841999687708ff128a8ffb0b88feb53e23168a3ce678b5393d",
+      "origin_type": "local_linux_build"
+    },
+    "gpu/bin/libaltd_gpu.so": {
+      "path": "gpu/bin/libaltd_gpu.so",
+      "bytes": 4711704,
+      "sha256": "3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca",
+      "origin_type": "retained_cuda_b90"
+    }
+  },
+  "checks": {
+    "native_tests": {
+      "status": "passed",
+      "receipt_path": "build/receipts/linux-native-tests.json",
+      "receipt_sha256": "ddb35821b16094bc0da624748e1f07e0b7a06cea4d4bc9baa28a7b6356bfacdb"
+    },
+    "cpu_smoke": {
+      "status": "passed",
+      "receipt_path": "build/receipts/linux-cpu-smoke.json",
+      "receipt_sha256": "afb4107c84bb38f21b9fabd6bbd9401b236ebff16ae2ce23230640994b8fd85c"
+    },
+    "gpu_layout": {
+      "status": "passed",
+      "receipt_path": "build/receipts/linux-gpu-layout.json",
+      "receipt_sha256": "45462cb6f4047e7715d6258fea60b9b39b1f8ea2e88ebbe3479454d53801cc00"
+    }
+  },
+  "gpu_device_execution": "not_run",
+  "compiler": {
+    "version": "rustc 1.95.0 (59807616e 2026-04-14)",
+    "host": "aarch64-apple-darwin",
+    "target": "x86_64-unknown-linux-gnu",
+    "cross_compiled": true,
+    "standard_library": {
+      "origin": "official_rust_distribution",
+      "url": "https://static.rust-lang.org/dist/2026-04-16/rust-std-1.95.0-x86_64-unknown-linux-gnu.tar.xz",
+      "sha256": "047ea7098803d3500fa1072e9cee5392697e21525559e4458128a2bf874aa382",
+      "installed_manifest_sha256": "46c1f8d1bcef24174217545ece8c22eb395a42e3534f618736c17a759a31e255"
+    },
+    "linker": {
+      "clang_version": "Apple clang version 21.0.0 (clang-2100.3.34.2)",
+      "lld_origin": "installed Rust1.95 bundled rust-lld",
+      "wrapper_path": "build/cross-tools/linux-linker",
+      "wrapper_sha256": "53fcd6801c00d79b669c231841079988a285e583142e59b1cdf29f8c19b1fc5f"
+    },
+    "sysroot": {
+      "origin": "read-only Ubuntu22.04 libraries copied from our existing nvidia/cuda:13.0.2-devel-ubuntu22.04 container",
+      "inventory_path": "build/receipts/linux-sysroot-inventory.json",
+      "inventory_sha256": "a4a9d33b5ec227a18b7f76f2df085fba372c5b6acd827cf28de84867df53ba6f"
+    }
+  },
+  "build_command": "/Users/tiga/.cargo/bin/cargo +1.95.0 build --target x86_64-unknown-linux-gnu --manifest-path build/source/Cargo.toml --release --locked --offline --no-default-features --features cli --bin altd-sim",
+  "build_environment": {
+    "CARGO_TARGET_DIR": "/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-target",
+    "CARGO_PROFILE_RELEASE_LTO": "false",
+    "CARGO_PROFILE_RELEASE_CODEGEN_UNITS": "16",
+    "CARGO_PROFILE_RELEASE_DEBUG": "0",
+    "CARGO_BUILD_JOBS": "4",
+    "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER": "/Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-tools/linux-linker",
+    "RUSTFLAGS": "--sysroot /Volumes/PATRIOT/ALD-TAO-lab/hf-winners-evaluation-v1.2-20261013/build/cross-sysroot -C target-cpu=x86-64"
+  },
+  "build_recipe_path": "build/recipes/native-cross-build.py",
+  "build_recipe_sha256": "17c731594d158bbc6627340954c1b2c53e90232fe2f89b48c2c33d73ae56fcc4",
+  "build_log_path": "build/receipts/native-cross-build.log",
+  "build_log_sha256": "d201fa42f1e379210dd385d394207e4afccb2d837e281ee86f6b4d992aa087f8",
+  "source_preserved": true,
+  "installed_toolchain_unchanged": true,
+  "original_baseline_binaries_unchanged": true
+}

native/source-receipt.json

@@ -0,0 +1,50 @@
+{
+  "schema": "ald-native-analysis-source-v1",
+  "upstream_revision": "b90b8af06ffc4ea4e4fd703becd1107a48b8e5e0",
+  "source_inventory_sha256": "3311905f217e08a927ca73d71db6687aaaf68f01cc2758e4028b92fa703bcebe",
+  "patch_sha256": "56859bc55a946ea129d502868387f8441cbd37c30962fe3e7e484d313c4ccf63",
+  "changed_source_files": [
+    {
+      "path": "src/bin/altd-sim/args.rs",
+      "baseline_sha256": "9f833f026d1f71ef76fe05d948464c619c76c15e43cedc11b5f510bfc337bda2",
+      "sha256": "7e94398fdae67500735a7be1ba6de6c576ed021d9c96011fd20ef0a3f3d3f3d7"
+    },
+    {
+      "path": "src/bin/altd-sim/main.rs",
+      "baseline_sha256": "841956a5a1a927b1a31369ccbd9aa18161b6328745a5a3ca4f02bdcfedd7230c",
+      "sha256": "3e679871a0978b2d68ce7cbb520584f1951adc8a0b584145966e58b6ca20e933"
+    },
+    {
+      "path": "src/bin/altd-sim/scratch/analysis.rs",
+      "baseline_sha256": null,
+      "sha256": "294c5c738de7fd573a3f3b89e4bdc8b35ba1c992b00959caa0bc75f19e41c3ba"
+    },
+    {
+      "path": "src/bin/altd-sim/scratch/mod.rs",
+      "baseline_sha256": "524e9033a1fb29ac7b4d689a21fede12b7bb77a772c078fce4c0bf4763568bbe",
+      "sha256": "1edaa2580112e4d0645743ab14bba16cf780d75800cd1036bd19f940bfc36680"
+    },
+    {
+      "path": "src/bin/altd-sim/scratch/runner.rs",
+      "baseline_sha256": "20a78bd99dc6bd69cc9314ba2d531dac13b5d9f21fb6ca676d34c0fa472a46c0",
+      "sha256": "0cab956fb0d63a20d6b62e01aadeb3d6592f4f12d601df095f41840a89329c55"
+    },
+    {
+      "path": "src/training/evolution.rs",
+      "baseline_sha256": "d050036c9346561411feefc6c94d598cb0f3ee69e85a8960cf911d60b2129a61",
+      "sha256": "488729530a2562295b44835716c7a4e055543614d0f262da682712cdac084460"
+    },
+    {
+      "path": "tests/winner_analysis.rs",
+      "baseline_sha256": null,
+      "sha256": "df3afd6faca830679afbefa4520b6947126bc972895df76504df6d42362ede28"
+    }
+  ],
+  "gpu_abi_source_unchanged": true,
+  "physics_source_unchanged": true,
+  "retained_cuda_library_sha256": "3b1b88bccc06a21acc33ac4400af016d55a7e3d8727136a0c43b541f3c7887ca",
+  "local_patch_semantics": "Host-only observations; unchanged simulation/evolution kernels. Descriptor helper reads native rewards without RNG; scratch frozen path resumes exact single policy and disables checkpoint turnover. Training state may be reused; evaluation uses fresh physical state.",
+  "mac_compiler": "rustc 1.95.0 (59807616e 2026-04-14)",
+  "mac_build_command": "cargo +1.95.0 --locked --offline --no-default-features --features cli; separate build/mac-target",
+  "linux_status": "passed"
+}

portable_bundle.py

@@ -1,6 +1,6 @@
 """Strict versioned portable bundle validator shared by CLI and hosted API."""
 from __future__ import annotations
-import base64, binascii, gzip, hashlib, io, json, math, os, re, sys
+import base64, binascii, gzip, hashlib, io, json, math, os, re, struct, sys, zlib
 from pathlib import Path
 from typing import Any
 PACKAGE_ROOT = Path(__file__).resolve().parent
@@ -13,8 +13,20 @@ MAX_NETWORK = 4 * 1024 * 1024
 MAX_TRACK = 1 * 1024 * 1024
 MAX_RECIPE = 32 * 1024
 MAX_RECEIPT = 512 * 1024
-MAX_BUNDLE = 8 * 1024 * 1024
+MAX_BUNDLE_V1 = 8 * 1024 * 1024
+MAX_BUNDLE = 48 * 1024 * 1024
 MAX_EXPANDED_JSON = 4 * 1024 * 1024
+ANALYSIS_ARCHIVE_FORMAT = "ald.run-analysis-archive+gzip"
+MAX_ANALYSIS_ARCHIVE = 32 * 1024 * 1024
+MAX_ANALYSIS_EXPANDED = 256 * 1024 * 1024
+MAX_ANALYSIS_FILE_BYTES = 192 * 1024 * 1024
+MAX_DESCRIPTOR_ROWS = 128000
+ANALYSIS_JSON_LIMIT = 512 * 1024
+ANALYSIS_WINNER_LIMIT = 1024 * 1024
+ANALYSIS_FILES = {
+    "analysis.json", "descriptors.jsonl", "evaluation.json",
+    "winners/fitness.evolution", "winners/fastest_lap.evolution", "winners/clean_laps.evolution",
+}
 HEX64 = re.compile(r"^[0-9a-f]{64}$")
 BUCKET_PATH = re.compile(r"^hf://buckets/([A-Za-z0-9][A-Za-z0-9_.-]{0,63})/([A-Za-z0-9][A-Za-z0-9_.-]{0,127})(?:/([A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)*))?$")
 SAFE_SEGMENT = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
@@ -23,19 +35,33 @@ RECIPE_KEYS = {
     "population", "generations", "ticks", "mutation", "seed", "mutation_end",
     "schedule", "selection", "parents", "elite", "crossover", "decay",
     "adaptive_mutation", "control_hz", "workers", "collision", "idle", "rewards",
+    "mode", "clean_min_laps",
 }
+LEGACY_RECIPE_KEYS = RECIPE_KEYS - {"mode", "clean_min_laps"}
 METRICS = {
     "total_score", "total_speed", "total_abs_steering", "total_actual_distance",
     "total_drifting_amount", "total_momentum_change_frequency", "total_throttle_change_frequency",
     "total_braking_frequency", "total_distance_from_wall", "total_distance_from_center",
     "network_novelty", "collision_count", "best_lap_performance", "total_racing_line_efficiency",
 }
+METRIC_ORDER = (
+    "total_score", "total_speed", "total_abs_steering", "total_actual_distance",
+    "total_drifting_amount", "total_momentum_change_frequency", "total_throttle_change_frequency",
+    "total_braking_frequency", "total_distance_from_wall", "total_distance_from_center",
+    "network_novelty", "collision_count", "best_lap_performance", "total_racing_line_efficiency",
+)
+AVERAGE_METRICS = set(METRIC_ORDER[:10])
+AVERAGE_ONLY_METRICS = {"total_abs_steering", "total_momentum_change_frequency", "total_throttle_change_frequency",
+                        "total_braking_frequency", "total_distance_from_wall", "total_distance_from_center"}
 RECEIPT_KEYS = {"version", "kind", "state", "build_id", "backend", "output_sha256", "report"}
 REPORT_KEYS = {
     "vehicle_type", "vehicle_name", "generations_completed", "generations_requested", "population",
     "elapsed_seconds", "best_score", "mean_score", "best_lap_seconds", "lapped_cars",
     "simulated_ticks", "requested_ticks", "candidate_validated", "execution_backend", "inputs", "settings",
 }
+ANALYSIS_SUMMARY_KEYS = {
+    "schema", "version", "mode", "execution_backend", "conditions", "observations", "winners", "semantics",
+}
 HISTORY_ROW_KEYS = {
     "generation", "mutation", "best_score", "mean_score",
     "best_lap_seconds", "lapped_cars", "simulated_ticks",
@@ -47,6 +73,374 @@ class BundleError(ValueError):
     pass
 
 
+def _analysis_member_limit(name: str) -> int:
+    if name in {"analysis.json", "evaluation.json"}:
+        return ANALYSIS_JSON_LIMIT
+    if name.startswith("winners/") and name.endswith(".evolution"):
+        return ANALYSIS_WINNER_LIMIT
+    if name == "descriptors.jsonl":
+        return MAX_ANALYSIS_FILE_BYTES
+    raise BundleError("analysis archive contains an unsupported filename")
+
+
+def _analysis_jsonl_rows(raw: bytes) -> int:
+    if not raw or not raw.endswith(b"\n"):
+        raise BundleError("analysis descriptors must be newline-terminated JSONL")
+    count = 0
+    for line in io.BytesIO(raw):
+        line = line[:-1] if line.endswith(b"\n") else line
+        if not line:
+            raise BundleError("analysis descriptors contain a blank row")
+        row = _parse_json(line, limit=64 * 1024, label="analysis descriptor row")
+        if not isinstance(row, dict):
+            raise BundleError("analysis descriptor row must be an object")
+        required = {"schema", "generation", "car", "candidate_id", "ticks_elapsed", "stats_update_count",
+                    "raw_metrics", "channels", "selection_fitness", "objectives", "weights_sha256"}
+        if set(row) != required or row.get("schema") != 1:
+            raise BundleError("analysis descriptor row fields are unsupported")
+        if (type(row["generation"]) is not int or not 1 <= row["generation"] <= 1000
+                or type(row["car"]) is not int or not 0 <= row["car"] < 128
+                or row["candidate_id"] != f'g{row["generation"]:06}-c{row["car"]:06}'
+                or type(row["ticks_elapsed"]) is not int or not 0 <= row["ticks_elapsed"] <= 18_012
+                or type(row["stats_update_count"]) is not int or not 0 <= row["stats_update_count"] <= 18_012
+                or not isinstance(row["weights_sha256"], str) or not HEX64.fullmatch(row["weights_sha256"])):
+            raise BundleError("analysis descriptor identity or counts are invalid")
+        metrics = row["raw_metrics"]
+        if (not isinstance(metrics, dict) or set(metrics) != METRICS
+                or any(v is not None and not _is_number(v, -1e12, 1e12)
+                       for k, v in metrics.items())):
+            raise BundleError("analysis descriptor raw metrics are invalid")
+        channels = row["channels"]
+        if (not isinstance(channels, dict)
+                or set(channels) != {"values", "population_relative", "unavailable_reasons"}
+                or any(not isinstance(channels[key], list) or len(channels[key]) != 18
+                       for key in ("values", "population_relative", "unavailable_reasons"))):
+            raise BundleError("analysis descriptor reward channels are invalid")
+        for value, rank, reason in zip(channels["values"], channels["population_relative"], channels["unavailable_reasons"]):
+            if value is None:
+                if rank is not None or not isinstance(reason, str) or not reason:
+                    raise BundleError("unavailable analysis channel is not represented explicitly")
+            elif (not _is_number(value, -1e12, 1e12) or not _is_number(rank, 0, 1) or reason is not None):
+                raise BundleError("available analysis channel is invalid")
+        if row["selection_fitness"] is not None and not _is_number(row["selection_fitness"], -1e12, 1e12):
+            raise BundleError("analysis descriptor selection fitness is invalid")
+        objectives = row["objectives"]
+        objective_keys = {"best_lap_seconds", "forward_laps", "physical_contacts", "collision_updates", "total_actual_distance", "active"}
+        if (not isinstance(objectives, dict) or set(objectives) != objective_keys
+                or any(objectives[k] is not None and not _is_number(objectives[k], 0, 1e12)
+                       for k in ("best_lap_seconds", "total_actual_distance"))
+                or any(type(objectives[k]) is not int or not 0 <= objectives[k] <= 4_000_000
+                       for k in ("forward_laps", "physical_contacts", "collision_updates"))
+                or type(objectives["active"]) is not bool):
+            raise BundleError("analysis descriptor objectives are invalid")
+        count += 1
+        if count > MAX_DESCRIPTOR_ROWS:
+            raise BundleError("analysis descriptor row limit exceeded")
+    return count
+
+
+def _network_weights_sha256(raw: bytes) -> str:
+    try:
+        network = _game_network_input(raw)["NeuralNetwork"]
+        digest = hashlib.sha256()
+        for matrix, bias in zip(network["Weights"], network["Biases"]):
+            for row in matrix:
+                for value in row:
+                    digest.update(struct.pack("<d", value))
+            for value in bias:
+                digest.update(struct.pack("<d", value))
+        return digest.hexdigest()
+    except (KeyError, TypeError, ValueError, OverflowError, struct.error) as exc:
+        raise BundleError("analysis winner network is invalid") from exc
+
+
+def load_analysis_archive(raw: bytes) -> tuple[dict[str, Any], dict[str, bytes]]:
+    """Validate the deterministic gzip envelope and return fixed inner members."""
+    if not isinstance(raw, bytes) or not raw or len(raw) > MAX_ANALYSIS_ARCHIVE:
+        raise BundleError("analysis archive is empty or exceeds 32 MiB")
+    if not raw.startswith(b"\x1f\x8b"):
+        raise BundleError("analysis archive is not gzip data")
+    inflater = zlib.decompressobj(16 + zlib.MAX_WBITS)
+    try:
+        expanded = inflater.decompress(raw, MAX_ANALYSIS_EXPANDED + 1)
+        if len(expanded) > MAX_ANALYSIS_EXPANDED or inflater.unconsumed_tail:
+            raise BundleError("analysis archive expands beyond 256 MiB")
+        expanded += inflater.flush(MAX_ANALYSIS_EXPANDED - len(expanded) + 1)
+    except zlib.error as exc:
+        raise BundleError("analysis archive gzip data is invalid") from exc
+    if len(expanded) > MAX_ANALYSIS_EXPANDED:
+        raise BundleError("analysis archive expands beyond 256 MiB")
+    if not inflater.eof or inflater.unused_data:
+        raise BundleError("analysis archive must contain one complete gzip member")
+    value = _parse_json(expanded, limit=MAX_ANALYSIS_EXPANDED, label="analysis archive envelope")
+    envelope = _strict_keys(value, {"schema", "version", "files"}, {"schema", "version", "files"}, "analysis archive")
+    if envelope["schema"] != "ald.run-analysis-archive" or type(envelope["version"]) is not int or envelope["version"] != 1:
+        raise BundleError("analysis archive schema or version is unsupported")
+    entries = envelope["files"]
+    if not isinstance(entries, list) or not 2 <= len(entries) <= len(ANALYSIS_FILES):
+        raise BundleError("analysis archive file list is invalid")
+    inner: dict[str, bytes] = {}
+    total = 0
+    for entry in entries:
+        entry = _strict_keys(entry, {"name", "bytes", "sha256", "data_base64"},
+                             {"name", "bytes", "sha256", "data_base64"}, "analysis archive member")
+        name = entry["name"]
+        if not isinstance(name, str) or name not in ANALYSIS_FILES or name in inner:
+            raise BundleError("analysis archive filename is unsupported or duplicated")
+        size = entry["bytes"]
+        limit = _analysis_member_limit(name)
+        if type(size) is not int or size < 1 or size > limit:
+            raise BundleError("analysis archive member size is invalid")
+        if not isinstance(entry["sha256"], str) or not HEX64.fullmatch(entry["sha256"]):
+            raise BundleError("analysis archive member SHA-256 is invalid")
+        encoded = entry["data_base64"]
+        if not isinstance(encoded, str) or len(encoded) > 4 * ((limit + 2) // 3):
+            raise BundleError("analysis archive member base64 exceeds its limit")
+        try:
+            content = base64.b64decode(encoded, validate=True)
+        except (ValueError, binascii.Error) as exc:
+            raise BundleError("analysis archive member base64 is invalid") from exc
+        if len(content) != size or hashlib.sha256(content).hexdigest() != entry["sha256"]:
+            raise BundleError("analysis archive member bytes or hash do not match")
+        total += len(content)
+        if total > MAX_ANALYSIS_FILE_BYTES:
+            raise BundleError("analysis archive members exceed 192 MiB")
+        inner[name] = content
+    if "analysis.json" not in inner or "descriptors.jsonl" not in inner:
+        raise BundleError("analysis archive is missing required files")
+    rows = _analysis_jsonl_rows(inner["descriptors.jsonl"])
+    analysis = _parse_json(inner["analysis.json"], limit=ANALYSIS_JSON_LIMIT, label="analysis metadata")
+    if analysis.get("schema") != "ald.run-analysis" or type(analysis.get("version")) is not int or analysis["version"] != 1:
+        raise BundleError("analysis metadata schema or version is unsupported")
+    mode = analysis.get("mode")
+    if not isinstance(mode, str):
+        raise BundleError("analysis mode is unsupported")
+    if mode == "train":
+        if "evaluation.json" in inner or "winners/fitness.evolution" not in inner:
+            raise BundleError("training analysis is missing its fitness winner or includes evaluation data")
+    elif mode == "evaluate":
+        if "evaluation.json" not in inner or any(name.startswith("winners/") for name in inner):
+            raise BundleError("evaluation analysis must include evaluation data and no selected winners")
+    else:
+        raise BundleError("analysis mode is unsupported")
+    observations = analysis.get("observations")
+    descriptors = analysis.get("descriptors")
+    if not isinstance(observations, dict) or not isinstance(descriptors, dict):
+        raise BundleError("analysis observation or descriptor metadata is missing")
+    if (type(observations.get("cars")) is not int or observations["cars"] != rows
+            or type(observations.get("generations")) is not int or not 1 <= observations["generations"] <= 1000
+            or type(observations.get("raw_metric_count")) is not int or observations["raw_metric_count"] != 14
+            or type(observations.get("reward_channel_count")) is not int or observations["reward_channel_count"] != 18):
+        raise BundleError("analysis observation counts do not match the descriptor rows")
+    if rows % observations["generations"]:
+        raise BundleError("analysis descriptor rows are not a whole number of generations")
+    expected_generation_cars = rows // observations["generations"]
+    if not 1 <= expected_generation_cars <= 128:
+        raise BundleError("analysis car population is outside its supported bounds")
+    if (descriptors.get("name") != "descriptors.jsonl"
+            or descriptors.get("bytes") != len(inner["descriptors.jsonl"])
+            or descriptors.get("sha256") != hashlib.sha256(inner["descriptors.jsonl"]).hexdigest()
+            or descriptors.get("rows") != rows):
+        raise BundleError("descriptor metadata does not match the complete descriptor file")
+    winners = analysis.get("winners")
+    if not isinstance(winners, dict) or set(winners) != {"fitness", "fastest_lap", "clean_laps"}:
+        raise BundleError("analysis winner roles are invalid")
+    expected_semantics = {"fitness", "fastest_lap", "clean_laps", "channels", "collision_count", "evaluation", "training"}
+    semantics = analysis.get("semantics")
+    if (not isinstance(semantics, dict) or set(semantics) != expected_semantics
+            or any(not isinstance(value, str) or not value or len(value) > 512 for value in semantics.values())):
+        raise BundleError("analysis semantics are invalid")
+    conditions = analysis.get("conditions")
+    if (not isinstance(conditions, dict)
+            or set(conditions) != {"track_sha256", "network_sha256", "vehicle_type", "requested_ticks", "control_hz", "collision", "idle", "math_profile", "clean_min_laps"}
+            or any(not isinstance(conditions[k], str) or not HEX64.fullmatch(conditions[k]) for k in ("track_sha256", "network_sha256"))
+            or type(conditions["vehicle_type"]) is not int or not 0 <= conditions["vehicle_type"] <= 3
+            or type(conditions["requested_ticks"]) is not int or not 1 <= conditions["requested_ticks"] <= 18_000
+            or type(conditions["control_hz"]) is not int or conditions["control_hz"] not in {15, 30, 60}
+            or type(conditions["collision"]) is not bool or type(conditions["idle"]) is not bool
+            or conditions["math_profile"] != "proton"
+            or type(conditions["clean_min_laps"]) is not int or not 1 <= conditions["clean_min_laps"] <= 100):
+        raise BundleError("analysis conditions are invalid")
+    metric_names = analysis.get("metric_names")
+    reward_channels = analysis.get("reward_channels")
+    if (not isinstance(metric_names, list) or tuple(metric_names) != METRIC_ORDER
+            or not isinstance(reward_channels, list) or len(reward_channels) != 18
+            or any(not isinstance(item, dict) or set(item) != {"metric", "type"}
+                   or not isinstance(item["metric"], str) or item["metric"] not in METRICS
+                   or not isinstance(item["type"], str) or item["type"] not in {"default", "average"}
+                   for item in reward_channels)
+            or reward_channels != [{"metric": metric, "type": kind} for metric in metric_names for kind in ("default", "average")
+                if not (kind == "default" and metric in AVERAGE_ONLY_METRICS)
+                and not (kind == "average" and metric not in AVERAGE_METRICS)]):
+        raise BundleError("analysis metric or reward channel definitions are invalid")
+    settings = analysis.get("settings")
+    if not isinstance(settings, dict) or set(settings) != RECIPE_KEYS:
+        raise BundleError("analysis validated settings are missing")
+    validate_settings(settings)
+    if (settings.get("mode") != mode or settings.get("ticks") != conditions["requested_ticks"]
+            or settings.get("control_hz") != conditions["control_hz"]
+            or settings.get("collision") != conditions["collision"]
+            or settings.get("idle") != conditions["idle"]
+            or settings.get("clean_min_laps") != conditions["clean_min_laps"]):
+        raise BundleError("analysis settings do not match its conditions")
+    if (type(settings.get("population")) is not int or not 1 <= settings["population"] <= 128
+            or type(settings.get("generations")) is not int or not 1 <= settings["generations"] <= 1000
+            or observations["generations"] != (1 if mode == "evaluate" else settings["generations"])
+            or expected_generation_cars != (1 if mode == "evaluate" else settings["population"])):
+        raise BundleError("analysis observation dimensions do not match its validated settings")
+    for role in ("fitness", "fastest_lap", "clean_laps"):
+        winner = winners[role]
+        winner_keys = {"status", "reason", "candidate_id", "generation", "car", "selection_fitness",
+                       "best_lap_seconds", "forward_laps", "physical_contacts", "collision_updates",
+                       "total_actual_distance", "artifact"}
+        if (not isinstance(winner, dict) or set(winner) != winner_keys
+                or not isinstance(winner.get("status"), str) or winner["status"] not in {"available", "unavailable"}):
+            raise BundleError("analysis winner status is invalid")
+        artifact = winner.get("artifact")
+        expected_name = f"winners/{role}.evolution"
+        if winner["status"] == "available":
+            if (not isinstance(winner["candidate_id"], str)
+                    or not re.fullmatch(r"g[0-9]{6}-c[0-9]{6}", winner["candidate_id"])
+                    or type(winner["generation"]) is not int or not 1 <= winner["generation"] <= observations["generations"]
+                    or type(winner["car"]) is not int or not 0 <= winner["car"] < expected_generation_cars
+                    or not _is_number(winner["selection_fitness"], -1e12, 1e12)
+                    or (winner["best_lap_seconds"] is not None and not _is_number(winner["best_lap_seconds"], 0, 1e12))
+                    or any(type(winner[k]) is not int or not 0 <= winner[k] <= 4_000_000
+                           for k in ("forward_laps", "physical_contacts", "collision_updates"))
+                    or (winner["total_actual_distance"] is not None and not _is_number(winner["total_actual_distance"], 0, 1e12))
+                    or winner["reason"] is not None):
+                raise BundleError("available winner observations are invalid")
+            if not isinstance(artifact, dict) or set(artifact) != {"name", "bytes", "sha256"}:
+                raise BundleError("available winner artifact metadata is invalid")
+            content = inner.get(expected_name)
+            if (artifact["name"] != expected_name or content is None
+                    or artifact["bytes"] != len(content)
+                    or artifact["sha256"] != hashlib.sha256(content).hexdigest()):
+                raise BundleError("winner file does not match its analysis manifest")
+            if _game_network_input(content)["Type"] != conditions["vehicle_type"]:
+                raise BundleError("winner network vehicle does not match the analysis conditions")
+        else:
+            if (artifact is not None or expected_name in inner or not isinstance(winner["reason"], str)
+                    or any(winner[k] is not None for k in ("candidate_id", "generation", "car", "selection_fitness",
+                        "best_lap_seconds", "forward_laps", "physical_contacts", "collision_updates", "total_actual_distance"))):
+                raise BundleError("unavailable winner metadata is invalid")
+    if mode == "train" and winners["fitness"]["status"] != "available":
+        raise BundleError("training analysis requires its fitness winner")
+    if mode == "evaluate" and any(winners[role]["status"] != "unavailable" for role in winners):
+        raise BundleError("evaluation analysis cannot select winners")
+    expected_files = {"analysis.json", "descriptors.jsonl"}
+    if mode == "train":
+        expected_files |= {f"winners/{role}.evolution" for role in winners if winners[role]["status"] == "available"}
+    else:
+        expected_files.add("evaluation.json")
+    if set(inner) != expected_files:
+        raise BundleError("analysis archive file set does not match its mode and winner manifest")
+    if mode == "evaluate":
+        evaluation = _parse_json(inner["evaluation.json"], limit=ANALYSIS_JSON_LIMIT, label="evaluation metadata")
+        if (not isinstance(evaluation, dict)
+                or set(evaluation) != {"schema", "version", "conditions", "input_sha256", "weights_unchanged", "measurements"}
+                or evaluation.get("schema") != "ald.frozen-evaluation"
+                or type(evaluation.get("version")) is not int or evaluation["version"] != 1
+                or evaluation.get("conditions") != conditions
+                or evaluation.get("weights_unchanged") is not True
+                or evaluation.get("input_sha256") != conditions["network_sha256"]):
+            raise BundleError("frozen evaluation metadata is invalid")
+        rows = list(io.BytesIO(inner["descriptors.jsonl"]))
+        if len(rows) != 1 or _parse_json(rows[0].rstrip(b"\n"), limit=64 * 1024, label="evaluation descriptor") != evaluation.get("measurements"):
+            raise BundleError("frozen evaluation measurement does not match its descriptor")
+    selected_ids = {winner["candidate_id"]: (role, winner) for role, winner in winners.items()
+                    if winner["status"] == "available"}
+    selected_rows = {}
+    population = expected_generation_cars
+    expected_role_rows: dict[str, dict[str, Any] | None] = {"fitness": None, "fastest_lap": None, "clean_laps": None}
+    for index, line in enumerate(io.BytesIO(inner["descriptors.jsonl"])):
+        line = line[:-1] if line.endswith(b"\n") else line
+        row = _parse_json(line, limit=64 * 1024, label="analysis descriptor row")
+        expected_generation = index // population + 1
+        expected_car = index % population
+        if row["generation"] != expected_generation or row["car"] != expected_car:
+            raise BundleError("analysis descriptor ordering is invalid")
+        if mode == "train":
+            if row["generation"] == observations["generations"]:
+                current = expected_role_rows["fitness"]
+                if current is None or row["selection_fitness"] > current["selection_fitness"]:
+                    expected_role_rows["fitness"] = row
+            lap = row["objectives"]["best_lap_seconds"]
+            forward_laps = row["objectives"]["forward_laps"]
+            if lap is not None and lap > 0 and forward_laps >= 1:
+                current = expected_role_rows["fastest_lap"]
+                if current is None or lap < current["objectives"]["best_lap_seconds"]:
+                    expected_role_rows["fastest_lap"] = row
+                if (forward_laps >= conditions["clean_min_laps"]
+                        and row["objectives"]["physical_contacts"] == 0):
+                    current = expected_role_rows["clean_laps"]
+                    if current is None or lap < current["objectives"]["best_lap_seconds"]:
+                        expected_role_rows["clean_laps"] = row
+        if row["candidate_id"] in selected_ids:
+            selected_rows[row["candidate_id"]] = row
+    if set(selected_rows) != set(selected_ids):
+        raise BundleError("winner metadata does not identify observed descriptor rows")
+    for role, expected in expected_role_rows.items():
+        winner = winners[role]
+        if expected is None:
+            expected_reason = "no_completed_lap" if role == "fastest_lap" else "no_eligible_clean_laps"
+            if mode == "evaluate":
+                expected_reason = "frozen_evaluation_does_not_select_winners"
+            if winner["status"] != "unavailable" or winner["reason"] != expected_reason:
+                raise BundleError("winner availability does not match the complete descriptor stream")
+        elif winner["status"] != "available" or winner["candidate_id"] != expected["candidate_id"]:
+            raise BundleError("winner selection does not match the complete descriptor stream")
+    for candidate_id, (role, winner) in selected_ids.items():
+        row = selected_rows[candidate_id]
+        objective = row["objectives"]
+        if (winner["generation"] != row["generation"] or winner["car"] != row["car"]
+                or winner["selection_fitness"] != row["selection_fitness"]
+                or _network_weights_sha256(inner[f"winners/{role}.evolution"]) != row["weights_sha256"]
+                or any(winner[key] != objective[key] for key in (
+                    "best_lap_seconds", "forward_laps", "physical_contacts", "collision_updates", "total_actual_distance"))):
+            raise BundleError("winner metadata does not match its observed descriptor")
+    return analysis, inner
+
+
+def make_analysis_archive(files: Any, *, primary: bytes, analysis_summary: Any = None) -> bytes:
+    if (not isinstance(files, dict) or not files
+            or any(not isinstance(name, str) for name in files)):
+        raise BundleError("analysis files must be a nonempty mapping")
+    if not isinstance(analysis_summary, dict):
+        raise BundleError("public analysis summary is required")
+    entries = []
+    total = 0
+    for name in sorted(files):
+        limit = _analysis_member_limit(name) if isinstance(name, str) else 0
+        content = files[name]
+        if not isinstance(content, bytes) or not content or len(content) > limit:
+            raise BundleError("analysis member is not bounded bytes")
+        total += len(content)
+        if total > MAX_ANALYSIS_FILE_BYTES:
+            raise BundleError("analysis files exceed 192 MiB")
+        entries.append({"name": name, "bytes": len(content),
+                        "sha256": hashlib.sha256(content).hexdigest(),
+                        "data_base64": base64.b64encode(content).decode("ascii")})
+    envelope = {"schema": "ald.run-analysis-archive", "version": 1, "files": entries}
+    expanded = _json_bytes(envelope)
+    if len(expanded) > MAX_ANALYSIS_EXPANDED:
+        raise BundleError("expanded analysis archive exceeds 256 MiB")
+    raw = gzip.compress(expanded, mtime=0)
+    if len(raw) > MAX_ANALYSIS_ARCHIVE:
+        raise BundleError("compressed analysis archive exceeds 32 MiB")
+    analysis, members = load_analysis_archive(raw)
+    fitness = members.get("winners/fitness.evolution")
+    if analysis.get("mode") == "train" and fitness != primary:
+        raise BundleError("primary result is not the manifested final fitness winner")
+    if (analysis.get("mode") == "evaluate"
+            and hashlib.sha256(primary).hexdigest() != analysis.get("conditions", {}).get("network_sha256")):
+        raise BundleError("frozen evaluation primary is not the original input network")
+    projection = {key: analysis.get(key) for key in ANALYSIS_SUMMARY_KEYS}
+    if analysis_summary != projection:
+        raise BundleError("public analysis summary does not match the private analysis archive")
+    return raw
+
+
 def _no_constant(value: str) -> None:
     raise BundleError(f"Non-finite JSON number is not allowed: {value}")
 
@@ -72,7 +466,7 @@ def _parse_json(raw: bytes, *, limit: int, label: str) -> Any:
         raise BundleError(f"{label} exceeds its byte limit")
     try:
         return json.loads(raw.decode("utf-8"), object_pairs_hook=_unique_object, parse_constant=_no_constant)
-    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+    except (UnicodeDecodeError, json.JSONDecodeError, RecursionError) as exc:
         raise BundleError(f"{label} must be valid UTF-8 JSON") from exc
 
 
@@ -94,18 +488,27 @@ def _is_number(value: Any, low: float, high: float) -> bool:
 
 
 def validate_settings(value: Any) -> dict[str, Any]:
-    settings = _strict_keys(value, RECIPE_KEYS, RECIPE_KEYS, "recipe settings")
+    settings = _strict_keys(value, RECIPE_KEYS, LEGACY_RECIPE_KEYS, "recipe settings")
+    settings.setdefault("mode", "train")
+    settings.setdefault("clean_min_laps", 2)
     bounds = {
         "population": (1, 128), "generations": (1, 1000), "ticks": (1, 18000),
         "seed": (0, 2147483647), "parents": (1, 128), "elite": (0, 128), "workers": (1, 4),
+        "clean_min_laps": (1, 100),
     }
     if any(not _is_int(settings[k], *bounds[k]) for k in bounds):
         raise BundleError("recipe settings contain an out-of-range integer")
     for key in ("mutation", "mutation_end"):
         if not _is_number(settings[key], 0, 4.2):
             raise BundleError("recipe mutation rates must be finite and between 0 and 4.2")
-    if settings["mutation"] <= 0 or (settings["schedule"] != "fixed" and settings["mutation_end"] <= 0):
+    if not isinstance(settings["mode"], str) or settings["mode"] not in {"train", "evaluate"}:
+        raise BundleError("recipe mode is unsupported")
+    if settings["mode"] == "train" and (settings["mutation"] <= 0 or (settings["schedule"] != "fixed" and settings["mutation_end"] <= 0)):
         raise BundleError("recipe mutation rates must be positive for the selected schedule")
+    if settings["mode"] == "evaluate" and (settings["population"] != 1 or settings["generations"] != 1
+            or settings["mutation"] != 0 or settings["mutation_end"] != 0 or settings["decay"] != 0
+            or settings["adaptive_mutation"] is not False or settings["parents"] != 1 or settings["elite"] != 0):
+        raise BundleError("frozen evaluation settings are not canonical")
     if not _is_number(settings["decay"], 0, 1):
         raise BundleError("recipe decay must be between 0 and 1")
     choices = {
@@ -152,7 +555,7 @@ def validate_recipe(value: Any) -> dict[str, Any]:
     return recipe
 
 
-def validate_receipt(value: Any) -> dict[str, Any]:
+def validate_receipt(value: Any, *, allow_analysis_summary: bool = False) -> dict[str, Any]:
     receipt = _strict_keys(value, RECEIPT_KEYS, RECEIPT_KEYS, "run receipt")
     if type(receipt["version"]) is not int or receipt["version"] != 1 or receipt["kind"] != "run":
         raise BundleError("run receipt version or kind is unsupported")
@@ -163,7 +566,24 @@ def validate_receipt(value: Any) -> dict[str, Any]:
         raise BundleError("run receipt build id is invalid")
     if not isinstance(receipt["output_sha256"], str) or not HEX64.fullmatch(receipt["output_sha256"]):
         raise BundleError("run receipt output hash is invalid")
-    report = _strict_keys(receipt["report"], REPORT_KEYS | {"history"}, REPORT_KEYS, "run receipt report")
+    optional_report = {"history"}
+    if allow_analysis_summary:
+        optional_report.add("analysis_summary")
+    report = _strict_keys(receipt["report"], REPORT_KEYS | optional_report, REPORT_KEYS, "run receipt report")
+    if "analysis_summary" in report:
+        if not allow_analysis_summary:
+            raise BundleError("legacy run receipt contains unsupported analysis summary")
+        summary = _strict_keys(report["analysis_summary"], ANALYSIS_SUMMARY_KEYS,
+                               ANALYSIS_SUMMARY_KEYS, "analysis summary")
+        if (summary["schema"] != "ald.run-analysis" or type(summary["version"]) is not int
+                or summary["version"] != 1 or not isinstance(summary["mode"], str)
+                or summary["mode"] not in {"train", "evaluate"}
+                or not isinstance(summary["execution_backend"], str)
+                or summary["execution_backend"] not in {"cpu", "cuda"}
+                or not isinstance(summary["conditions"], dict)
+                or not isinstance(summary["observations"], dict)
+                or not isinstance(summary["winners"], dict)):
+            raise BundleError("analysis summary is invalid")
     if not _is_int(report["vehicle_type"], 0, 3) or report["vehicle_name"] != ("Formula", "Rally", "Snowmobile", "Truck")[report["vehicle_type"]]:
         raise BundleError("run receipt vehicle is invalid")
     for key in ("generations_completed", "generations_requested", "population", "simulated_ticks", "requested_ticks"):
@@ -302,13 +722,28 @@ def _decode_slot(value: Any, *, role: str, limit: int, fmt: str, allowed_extra:
     return raw
 
 
+def _decode_analysis_slot(value: Any) -> bytes:
+    slot = _strict_keys(value, {"format", "bytes", "sha256", "data_base64"},
+                        {"format", "bytes", "sha256", "data_base64"}, "analysis archive slot")
+    return _decode_slot(slot, role="analysis archive", limit=MAX_ANALYSIS_ARCHIVE,
+                        fmt=ANALYSIS_ARCHIVE_FORMAT, allowed_extra=set(), required_extra=set())
+
+
 def load_bundle(raw: bytes, *, catalog_path: Path | None = None) -> tuple[dict[str, Any], dict[str, bytes]]:
     value = _parse_json(raw, limit=MAX_BUNDLE, label="bundle")
     bundle = _strict_keys(value, {"schema", "version", "artifacts"}, {"schema", "version", "artifacts"}, "bundle")
-    if bundle["schema"] != SCHEMA or type(bundle["version"]) is not int or bundle["version"] != VERSION:
+    version = bundle["version"]
+    if bundle["schema"] != SCHEMA or type(version) is not int or version not in {1, 2}:
         raise BundleError("bundle schema or version is unsupported")
+    if version == 1 and len(raw) > MAX_BUNDLE_V1:
+        raise BundleError("legacy bundle exceeds its 8 MiB limit")
     artifacts = bundle["artifacts"]
-    if not isinstance(artifacts, dict) or not {"selected_network"} <= set(artifacts) or set(artifacts) - {"selected_network", "selected_track", "selected_recipe", "run_receipt"}:
+    allowed_artifacts = {"selected_network", "selected_track", "selected_recipe", "run_receipt"}
+    if version == 2:
+        allowed_artifacts.add("analysis_archive")
+    if (not isinstance(artifacts, dict) or not {"selected_network"} <= set(artifacts)
+            or set(artifacts) - allowed_artifacts
+            or (version == 2 and "analysis_archive" not in artifacts)):
         raise BundleError("bundle must contain a selected network and only supported optional artifacts")
     files: dict[str, bytes] = {}
     net = _strict_keys(artifacts["selected_network"], {"format", "kind", "bytes", "sha256", "data_base64"}, {"format", "kind", "bytes", "sha256", "data_base64"}, "selected network")
@@ -354,15 +789,63 @@ def load_bundle(raw: bytes, *, catalog_path: Path | None = None) -> tuple[dict[s
             raise BundleError("selected recipe exceeds 32 KiB")
         files["selected_recipe.json"] = recipe_bytes
 
+    analysis = None
+    analysis_members: dict[str, bytes] = {}
+    if version == 2:
+        archive_bytes = _decode_analysis_slot(artifacts["analysis_archive"])
+        analysis, analysis_members = load_analysis_archive(archive_bytes)
+        files["analysis_archive.gz"] = archive_bytes
+        files.update({f"analysis/{name}": content for name, content in analysis_members.items()})
+        if net["kind"] != "result" or "run_receipt" not in artifacts or "selected_track" not in artifacts:
+            raise BundleError("analysis bundles must contain a result network and run receipt")
+
     if "run_receipt" in artifacts:
-        receipt = validate_receipt(artifacts["run_receipt"])
+        receipt = validate_receipt(artifacts["run_receipt"], allow_analysis_summary=version == 2)
         report = receipt["report"]
         network_sha = net["sha256"]
-        if net["kind"] == "input":
+        if version == 2:
+            if not isinstance(report.get("analysis_summary"), dict):
+                raise BundleError("v2 run receipt is missing its analysis summary")
+            projection = {key: analysis.get(key) for key in ANALYSIS_SUMMARY_KEYS}
+            if report["analysis_summary"] != projection:
+                raise BundleError("run receipt analysis summary does not match its archive")
+            conditions = analysis.get("conditions")
+            if (not isinstance(conditions, dict)
+                    or conditions.get("track_sha256") != report["inputs"]["track_sha256"]
+                    or conditions.get("network_sha256") != report["inputs"]["network_sha256"]
+                    or conditions.get("vehicle_type") != report["vehicle_type"]
+                    or conditions.get("requested_ticks") != report["requested_ticks"]
+                    or analysis.get("execution_backend") != report["execution_backend"]):
+                raise BundleError("analysis archive conditions do not match the run receipt")
+            if analysis.get("mode") == "evaluate":
+                evaluation = _parse_json(analysis_members["evaluation.json"], limit=ANALYSIS_JSON_LIMIT,
+                                         label="evaluation metadata")
+                if (evaluation.get("schema") != "ald.frozen-evaluation"
+                        or evaluation.get("version") != 1
+                        or evaluation.get("weights_unchanged") is not True
+                        or evaluation.get("input_sha256") != report["inputs"]["network_sha256"]
+                        or network_sha != report["inputs"]["network_sha256"]):
+                    raise BundleError("frozen evaluation does not preserve the input network")
+                if _network_weights_sha256(files["selected_network.evolution"]) != evaluation["measurements"]["weights_sha256"]:
+                    raise BundleError("frozen evaluation descriptor does not match the input weights")
+            else:
+                fitness = analysis["winners"]["fitness"]
+                fitness_bytes = analysis_members["winners/fitness.evolution"]
+                if (fitness.get("artifact", {}).get("sha256") != receipt["output_sha256"]
+                        or hashlib.sha256(fitness_bytes).hexdigest() != receipt["output_sha256"]):
+                    raise BundleError("run output hash does not match its final fitness winner")
+                selected_is_winner = any(
+                    analysis["winners"][role]["status"] == "available"
+                    and analysis_members.get(f"winners/{role}.evolution") == files["selected_network.evolution"]
+                    for role in ("fitness", "fastest_lap", "clean_laps")
+                )
+                if not selected_is_winner:
+                    raise BundleError("selected network is not byte-identical to an archived winner")
+        elif net["kind"] == "input":
             network_matches = report["inputs"]["network_sha256"] == network_sha
         else:
             network_matches = receipt["output_sha256"] == network_sha
-        if not network_matches:
+        if version == 1 and not network_matches:
             raise BundleError("run receipt does not describe the bundled network")
         if "selected_track" in artifacts and report["inputs"]["track_sha256"] != artifacts["selected_track"]["sha256"]:
             raise BundleError("run receipt does not describe the bundled track")

server.py

@@ -8,20 +8,23 @@ import threading
 from fastapi import HTTPException, Request
 from fastapi.responses import FileResponse, Response, HTMLResponse, JSONResponse
 from starlette.concurrency import run_in_threadpool
-from delivery import create_api, CapacityExceeded
+from delivery import create_api, CapacityExceeded, InvalidAnalysisOutput, publish_worker_result
 from worker import run_reported
 from build_info import build_identity
 from training_config import validate_config
 from hf_identity import oauth_config
 from builtin_tracks import TrackLibrary
 from steam_leaderboard import compare_public_best_lap, milliseconds, SteamUnavailable
-from bucket_storage import BucketStorageError, MAX_REQUEST as BUCKET_MAX_REQUEST, run_bucket_operation, valid_bucket_id, valid_bundle_key
-from portable_bundle import BundleError, load_bundle, MAX_BUNDLE, MAX_NETWORK
+from bucket_storage import (BucketStorageError, MAX_REQUEST as BUCKET_MAX_REQUEST,
+    MAX_RECIPE_LIBRARY, run_bucket_operation, valid_bucket_id, valid_bundle_key,
+    valid_recipe_key, validate_recipe_library, AUTOSAVE_APP_KEY, winner_sidecar_filename)
+from portable_bundle import (BundleError, load_bundle, MAX_BUNDLE, MAX_NETWORK,
+    MAX_ANALYSIS_ARCHIVE, MAX_ANALYSIS_FILE_BYTES)
 
 ROOT=Path(__file__).resolve().parent
-EVOLUTION_SIDECAR=re.compile(r'^[a-z0-9][a-z0-9-]{0,63}-(formula|rally|snowmobile|truck)-[0-9]{8}T[0-9]{6}Z-[0-9a-f]{8}\.evolution$')
+EVOLUTION_SIDECAR=re.compile(r'^[a-z0-9][a-z0-9-]{0,63}-(formula|rally|snowmobile|truck)-[0-9]{8}T[0-9]{6}Z-[0-9a-f]{8}(?:-(fitness-winner|fastest-lap-winner|clean-laps-winner))?\.evolution$')
 
-def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None):
+def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None,require_analysis=False):
     app=create_api(store)
     admission=threading.BoundedSemaphore(1)
     leaderboard_admission=threading.BoundedSemaphore(1)
@@ -96,10 +99,24 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
                 except BundleError: raise HTTPException(400,'Invalid portable bundle') from None
                 bundle_raw=bundle.encode('utf-8')
                 call_args={'bundle_base64':base64.b64encode(bundle_raw).decode('ascii')}
+            elif operation=='recipes_save':
+                library=body.get('library')
+                if not isinstance(library,str): raise HTTPException(400,'Invalid recipe library')
+                try: library_raw=library.encode('utf-8')
+                except UnicodeEncodeError: raise HTTPException(400,'Invalid recipe library') from None
+                if len(library_raw)>MAX_RECIPE_LIBRARY:
+                    raise HTTPException(413,'Recipe library too large')
+                try: validate_recipe_library(library_raw)
+                except Exception: raise HTTPException(400,'Invalid recipe library') from None
+                call_args={'library_base64':base64.b64encode(library_raw).decode('ascii')}
             elif operation=='restore':
                 if not valid_bundle_key(body.get('key')):
                     raise HTTPException(400,'Invalid storage request')
                 call_args={'key':body['key']}
+            elif operation=='recipes_restore':
+                if not valid_recipe_key(body.get('key')):
+                    raise HTTPException(400,'Invalid storage request')
+                call_args={'key':body['key']}
             else:
                 call_args={}
             try:
@@ -110,6 +127,9 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
                 result['_validated_bundle_bytes']=bundle_raw
                 result['_validated_bundle_files']=bundle_files
                 result['_validated_bundle_has_receipt']='run_receipt' in bundle_obj['artifacts']
+            if operation=='recipes_save':
+                result['_validated_library_bytes']=library_raw
+                result['_validated_bucket_id']=body['bucket_id']
             return result
         finally:
             bucket_admission.release()
@@ -134,7 +154,19 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
         required={'bundle.json'}
         if has_receipt:
             required|={'report.md','generation-history.csv'}
-        evolution=[name for name in verified if isinstance(name,str) and EVOLUTION_SIDECAR.fullmatch(name)] if isinstance(verified,dict) else []
+        if isinstance(bundle_files,dict) and 'analysis_archive.gz' in bundle_files:
+            required.add('analysis-archive.gz')
+            required.update(name for name in bundle_files if name.startswith('analysis/'))
+            key_match=AUTOSAVE_APP_KEY.fullmatch(result.get('key',''))
+            if key_match is None:
+                raise HTTPException(502,'Storage operation failed')
+            for role in ('fitness','fastest_lap','clean_laps'):
+                inner=f'analysis/winners/{role}.evolution'
+                if inner in bundle_files:
+                    required.add(winner_sidecar_filename(key_match.group('track'),key_match.group('vehicle'),
+                        key_match.group('timestamp'),key_match.group('uuid')[:8],role))
+        evolution=[name for name in verified if isinstance(name,str)
+                   and (match:=EVOLUTION_SIDECAR.fullmatch(name)) and match.group(2) is None] if isinstance(verified,dict) else []
         if len(evolution)!=1 or not isinstance(verified,dict) or set(verified)!=(required|{evolution[0]}):
             raise HTTPException(502,'Storage operation failed')
         if not isinstance(raw,bytes) or not isinstance(bundle_files,dict):
@@ -142,23 +174,81 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
         network=bundle_files['selected_network.evolution']
         safe_verified={}
         total=0
+        per_file_limit=MAX_ANALYSIS_FILE_BYTES
         for name,proof in verified.items():
             if (not isinstance(proof,dict) or set(proof)!={'bytes','sha256'}
-                    or type(proof['bytes']) is not int or not 0<=proof['bytes']<=MAX_BUNDLE
+                    or type(proof['bytes']) is not int or not 0<=proof['bytes']<=per_file_limit
                     or not isinstance(proof['sha256'],str) or not re.fullmatch(r'[0-9a-f]{64}',proof['sha256'])):
                 raise HTTPException(502,'Storage operation failed')
             total+=proof['bytes']
             safe_verified[name]={'bytes':proof['bytes'],'sha256':proof['sha256']}
-        if (total>MAX_BUNDLE+MAX_NETWORK+1024*1024
+        if (total>MAX_BUNDLE+MAX_NETWORK+320*1024*1024
                 or safe_verified['bundle.json']!={'bytes':len(raw),'sha256':hashlib.sha256(raw).hexdigest()}
                 or safe_verified[evolution[0]]!={'bytes':len(network),'sha256':hashlib.sha256(network).hexdigest()}):
             raise HTTPException(502,'Storage operation failed')
+        analysis_archive=bundle_files.get('analysis_archive.gz')
+        if analysis_archive is not None and safe_verified.get('analysis-archive.gz')!={
+                'bytes':len(analysis_archive),'sha256':hashlib.sha256(analysis_archive).hexdigest()}:
+            raise HTTPException(502,'Storage operation failed')
+        for filename,content in bundle_files.items():
+            if filename.startswith('analysis/') and safe_verified.get(filename)!={
+                    'bytes':len(content),'sha256':hashlib.sha256(content).hexdigest()}:
+                raise HTTPException(502,'Storage operation failed')
+        for role in ('fitness','fastest_lap','clean_laps'):
+            inner=f'analysis/winners/{role}.evolution'
+            key_match=AUTOSAVE_APP_KEY.fullmatch(result.get('key',''))
+            sidecar=(winner_sidecar_filename(key_match.group('track'),key_match.group('vehicle'),
+                key_match.group('timestamp'),key_match.group('uuid')[:8],role) if key_match else '')
+            if inner in bundle_files and safe_verified.get(sidecar)!={
+                    'bytes':len(bundle_files[inner]),'sha256':hashlib.sha256(bundle_files[inner]).hexdigest()}:
+                raise HTTPException(502,'Storage operation failed')
         return JSONResponse({key:result[key] for key in ('status','bucket_id','key','bytes','sha256')}|{'verified_files':safe_verified},headers={'Cache-Control':'no-store'})
 
     @app.post('/api/bucket/restore')
     async def bucket_restore(request:Request):
         result=await bucket_operation(request,'restore',fields={'bucket_id','key'})
         return Response(result['bundle_bytes'],media_type='application/json',headers={'Cache-Control':'no-store','X-Content-Type-Options':'nosniff'})
+
+    @app.post('/api/bucket/recipes/list')
+    async def bucket_recipes_list(request:Request):
+        result=await bucket_operation(request,'recipes_list',fields={'bucket_id'})
+        items=result.get('items')
+        if (not isinstance(items,list) or type(result.get('truncated')) is not bool
+                or type(result.get('scan_incomplete')) is not bool or len(items)>50):
+            raise HTTPException(502,'Storage operation failed')
+        clean=[]
+        for item in items:
+            if (not isinstance(item,dict) or set(item)!={'key','bytes','label','created_at'}
+                    or not valid_recipe_key(item.get('key')) or type(item.get('bytes')) is not int
+                    or not 0<=item['bytes']<=MAX_RECIPE_LIBRARY
+                    or not isinstance(item.get('label'),str) or len(item['label'])>192
+                    or (item.get('created_at') is not None and not isinstance(item.get('created_at'),str))):
+                raise HTTPException(502,'Storage operation failed')
+            clean.append(item)
+        return JSONResponse({'items':clean,'truncated':result['truncated'],
+                             'scan_incomplete':result['scan_incomplete']},headers={'Cache-Control':'no-store'})
+
+    @app.post('/api/bucket/recipes/save')
+    async def bucket_recipes_save(request:Request):
+        result=await bucket_operation(request,'recipes_save',fields={'bucket_id','library'},
+                                      limit=MAX_RECIPE_LIBRARY*6+4096)
+        raw=result.pop('_validated_library_bytes',None)
+        expected_bucket=result.pop('_validated_bucket_id',None)
+        verified=result.pop('verified_bytes',None)
+        if (not isinstance(raw,bytes) or verified!=raw or result.get('status')!='saved_verified'
+                or result.get('bucket_id')!=expected_bucket or not valid_recipe_key(result.get('key'))
+                or result.get('bytes')!=len(raw) or result.get('sha256')!=hashlib.sha256(raw).hexdigest()):
+            raise HTTPException(502,'Storage operation failed')
+        return JSONResponse({key:result[key] for key in ('status','bucket_id','key','bytes','sha256')},
+                            headers={'Cache-Control':'no-store'})
+
+    @app.post('/api/bucket/recipes/restore')
+    async def bucket_recipes_restore(request:Request):
+        result=await bucket_operation(request,'recipes_restore',fields={'bucket_id','key'})
+        raw=result.get('recipe_bytes')
+        if not isinstance(raw,bytes) or not valid_recipe_key(result.get('key')):
+            raise HTTPException(502,'Storage operation failed')
+        return Response(raw,media_type='application/json',headers={'Cache-Control':'no-store','X-Content-Type-Options':'nosniff'})
     @app.get('/api/tracks')
     def track_catalog():
         return JSONResponse(library.catalog(),headers={'Cache-Control':'no-store'})
@@ -260,8 +350,11 @@ def create_app(worker=run_reported,store=None,gpu_worker=None,track_library=None
             try:
                 result=await run_in_threadpool(selected,track,network,config) if config is not None else await run_in_threadpool(selected,track,network)
                 payload,report=result if isinstance(result,tuple) else (result,None)
-                return {**app.state.results.publish(payload,automatic),'backend':backend,'report':report}
+                published,public_report=publish_worker_result(
+                    app.state.results,payload,report,automatic,require_analysis=require_analysis)
+                return {**published,'backend':backend,'report':public_report}
             except CapacityExceeded: raise HTTPException(503,'Result capacity reached') from None
+            except InvalidAnalysisOutput: raise HTTPException(422,'Processing failed; complete analysis could not be verified.') from None
             except Exception: raise HTTPException(422,'Processing failed; no result published. Cleanup status requires verification.') from None
         finally: admission.release()
     return app

training_config.py

@@ -2,7 +2,7 @@
 import copy
 import math
 
-DEFAULTS={'population':4,'generations':1,'ticks':60,'mutation':.01,'seed':42,
+DEFAULTS={'mode':'train','clean_min_laps':2,'population':4,'generations':1,'ticks':60,'mutation':.01,'seed':42,
     'mutation_end':.01,'schedule':'fixed','selection':'best','parents':1,'elite':1,
     'crossover':'none','decay':0,'adaptive_mutation':False,'control_hz':30,'workers':1,
     'collision':False,'idle':False,'rewards':[{'metric':'total_score','type':'default','weight':100}]}
@@ -17,17 +17,17 @@ def validate_config(value=None):
     c={**copy.deepcopy(DEFAULTS),**value}
     bounds={'population':(1,128,True),'generations':(1,1000,True),'ticks':(1,18000,True),
         'mutation':(0,4.2,False),'mutation_end':(0,4.2,False),'seed':(0,2147483647,True),
-        'parents':(1,128,True),'elite':(0,128,True),'decay':(0,1,False),'workers':(1,4,True)}
+        'clean_min_laps':(1,100,True),'parents':(1,128,True),'elite':(0,128,True),'decay':(0,1,False),'workers':(1,4,True)}
     for key,(low,high,integer) in bounds.items():
         v=c[key]
         if type(v) not in (int,float) or not math.isfinite(v) or not low<=v<=high or (integer and type(v) is not int):raise ValueError('Invalid '+key)
-    for key,choices in {'schedule':('fixed','linear','geometric'),'selection':('best','tournament','roulette'),
+    for key,choices in {'mode':('train','evaluate'),'schedule':('fixed','linear','geometric'),'selection':('best','tournament','roulette'),
                         'crossover':('none','single_point','uniform'),'control_hz':(60,30,15)}.items():
         if c[key] not in choices or (key=='control_hz' and type(c[key]) is not int):raise ValueError('Invalid '+key)
     for key in ('adaptive_mutation','collision','idle'):
         if type(c[key]) is not bool:raise ValueError('Invalid '+key)
-    if c['parents']>c['population'] or c['elite']>c['population']:raise ValueError('Parents/elites exceed population')
-    if c['mutation']<=0 or (c['schedule']!='fixed' and c['mutation_end']<=0):raise ValueError('This training runner requires positive mutation rates, including when continuing an uploaded network')
+    if c['mode']=='train' and (c['parents']>c['population'] or c['elite']>c['population']):raise ValueError('Parents/elites exceed population')
+    if c['mode']=='train' and (c['mutation']<=0 or (c['schedule']!='fixed' and c['mutation_end']<=0)):raise ValueError('This training runner requires positive mutation rates, including when continuing an uploaded network')
     # Echo the rate actually passed to the native CLI, not an unused form value.
     if c['schedule']=='fixed':c['mutation_end']=c['mutation']
     rewards=c['rewards']
@@ -39,5 +39,7 @@ def validate_config(value=None):
         seen.add(r['metric']);clean.append(dict(r))
     if not any(r['weight'] for r in clean):raise ValueError('A reward weight must be nonzero')
     c['rewards']=clean
+    if c['mode']=='evaluate':
+        c.update(population=1,generations=1,mutation=0,mutation_end=0,decay=0,adaptive_mutation=False,parents=1,elite=0,crossover='none',selection='best',schedule='fixed')
     if c['population']*c['generations']*c['ticks']>4_000_000:raise ValueError('Run exceeds preview work limit (4,000,000 vehicle-ticks)')
     return c

worker.py

@@ -16,6 +16,7 @@ import time
 import uuid
 from training_config import validate_config
 from build_info import build_identity
+from analysis_result import assemble_analysis
 
 MODULE_DIR = Path(__file__).resolve().parent
 # Source checkout is nested; a hosted release is flat under /app. Deployment
@@ -188,19 +189,23 @@ def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_templ
             '--out-dir',str(out),'--mutation-start',str(config['mutation']),
             '--mutation-end',str(config['mutation'] if config['schedule']=='fixed' else config['mutation_end']),
             '--schedule','linear' if config['schedule']=='fixed' else config['schedule'],'--save-final-candidate',
+            '--checkpoint-every','0','--analysis','--clean-min-laps',str(config['clean_min_laps']),
             '--eliminate-on-wall' if config['collision'] else '--no-eliminate-on-wall',
             '--idle-eliminate' if config['idle'] else '--no-idle-eliminate']
+        if config['mode']=='evaluate':command.append('--evaluate-frozen')
         if gpu_library is not None: command.append('--gpu')
         subprocess.run(command,cwd=work,env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=25,check=True)
-        candidate=out/'candidate.json'
-        if candidate.stat().st_size>1024*1024: raise ValueError('Output too large')
-        trained=json.loads(candidate.read_text())
-        n['Weights']=trained['weights']; n['Biases']=trained['biases']
-        result=gzip.compress(json.dumps(template,allow_nan=False).encode(),mtime=0)
+        if config['mode']=='train':
+            candidate=out/'candidate.json'
+            if candidate.stat().st_size>1024*1024: raise ValueError('Output too large')
+            trained=json.loads(candidate.read_text())
+            n['Weights']=trained['weights']; n['Biases']=trained['biases']
+        result=(network_bytes if config['mode']=='evaluate' else gzip.compress(json.dumps(template,allow_nan=False).encode(),mtime=0))
         network_input(result)
         history=[json.loads(line) for line in (out/'log.jsonl').read_text().splitlines() if line.strip()]
         last=history[-1] if history else {}
-        report={'build':build_identity(),'state':'completed','elapsed_seconds':time.perf_counter()-started,
+        files,summary,evaluation=assemble_analysis(out,template,result,network_bytes,track_bytes,config,'cuda' if gpu_library is not None else 'cpu',network_input)
+        report={'mode':config['mode'],'analysis_summary':summary,'_analysis_files':files,'build':build_identity(),'state':'completed','elapsed_seconds':time.perf_counter()-started,
             'generations_completed':len(history),'generations_requested':config['generations'],'population':config['population'],
             'best_score':last.get('best_score'),'mean_score':last.get('mean_score'),
             'best_lap_seconds':best_run_lap(history),'best_lap_scope':'Best completed lap observed during this run; may belong to a different car than the exported candidate','lapped_cars':last.get('lapped_cars'),