Publish verified 164-dataset native matrix and recovery results

Publish the complete 164 x 85 terminal matrix, 174 independently accepted recovery pairs, and receipt-bound timing admission. Preserve N/A and failure coverage, exact support-set ranking, execution-host and adapter distinctions. Exclude GLZA. The ongoing 328-pair recovery remains pending until joint independent acceptance. All 28 files match the reviewed v6 freeze receipt.

NATIVE86_FULL_MATRIX_INTEGRATION_V6.json

@@ -0,0 +1,362 @@
+{
+  "counts": {
+    "accepted_repair_overlap_pair_count": 1,
+    "accepted_unique_repair_pair_count": 174,
+    "active_method_count": 85,
+    "comparison_profiles": {
+      "cpp-native166-main-458a218f": {
+        "dataset_result_count": 25443,
+        "exact_source_profiles": [
+          "cpp-native166-main-458a218f"
+        ],
+        "execution_host": "166.111.68.166",
+        "pair_count": 11164,
+        "timing_admitted": true
+      },
+      "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 383,
+        "exact_source_profiles": [
+          "cpp-native166-recovery-3452a998",
+          "cpp-native166-recovery-39dc8c5d",
+          "cpp-native166-recovery-458a218f",
+          "cpp-native166-recovery-813812e1",
+          "cpp-native166-recovery-82297044",
+          "cpp-native166-recovery-9abdc80f"
+        ],
+        "execution_host": "166.111.68.166",
+        "pair_count": 154,
+        "timing_admitted": false
+      },
+      "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 29,
+        "exact_source_profiles": [
+          "cpp-native192-first12-3452a998",
+          "cpp-native192-first12-39dc8c5d",
+          "cpp-native192-first12-9abdc80f",
+          "cpp-native192-first12-bf0a069f"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 12,
+        "timing_admitted": false
+      },
+      "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2": {
+        "dataset_result_count": 5,
+        "exact_source_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-41d0e8fc"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_admitted": false
+      },
+      "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1": {
+        "dataset_result_count": 6,
+        "exact_source_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-00f34de8"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_admitted": false
+      },
+      "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 15,
+        "exact_source_profiles": [
+          "cpp-native192-next5-39dc8c5d",
+          "cpp-native192-next5-9abdc80f",
+          "cpp-native192-next5-bf0a069f"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 5,
+        "timing_admitted": false
+      }
+    },
+    "created_at": "2026-10-11T08:53:18.361574+00:00",
+    "dataset_count": 164,
+    "dropped_mixed_overall_count": 1708,
+    "files": {
+      "COVERAGE_SANITY.full_main166_dataset_results.jsonl.gz": {
+        "published_support_aware_rows": 25443,
+        "source_rows": 27151,
+        "source_sha256": "a9e0e5b790ca8aa320d8696cb4af54835725401b0450fa980765534dc92b3c74"
+      },
+      "legacy-dbp-medium-posts-independent-review.json": {
+        "sha256": "ec4095da7f99aebc07a4768cef15cba713a1b9e68a03d7ce41b23a9e7da3e5fd",
+        "source_sha256": "a200679cddddd96e7bd7488d499dcdeace7f098195e8ead502f70dc49af49043",
+        "status": "passed"
+      },
+      "legacy-dbp-medium-posts-timing-receipt.json": {
+        "sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+        "source_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+        "status": "passed"
+      },
+      "native86-main166-dataset-results.jsonl.gz": {
+        "published_support_aware_rows": 25443,
+        "sha256": "a9e0e5b790ca8aa320d8696cb4af54835725401b0450fa980765534dc92b3c74",
+        "source_rows": 27151
+      },
+      "native86-main166-independent-adjudication.json": {
+        "sha256": "ada06b5191e0edf92c862c68bb21562e7d46fbef014e71fb775a1b2b44dcf004",
+        "status": "partial_verification_blocked"
+      },
+      "native86-main166-pair-adjudication.jsonl": {
+        "rows": 920,
+        "sha256": "f55be6435dd7ff90dd04777f693299e73a2ef42fdf0e59f58eb3f1aa247e8aab"
+      },
+      "native86-main166-timing-proof.json": {
+        "sha256": "f0f502d348fa20f336911f960efb63da07ddfbe922327acc636554e36d62590c",
+        "status": "passed"
+      },
+      "native86-recovery-reconciliation.json": {
+        "accepted_unique_repair_pairs": 174,
+        "sha256": "39f05a3195a1aeb3ad23114322b40fa91a205e5f798e1ceb7598beb91ae7c0f2",
+        "status": "passed_with_one_omitted_problem_scheduled_for_separate_sidecar",
+        "unresolved_problem_pairs": 328
+      },
+      "native86-terminal-matrix.jsonl.gz": {
+        "rows": 13940,
+        "sha256": "1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9"
+      },
+      "native86-v9-current154-thin.jsonl.gz": {
+        "not_applicable_aggregates": 308,
+        "numeric_ok_aggregates": 5296,
+        "pairs": 154,
+        "sha256": "f538e84dd2b4fee3c1b0d68408095fc88714eafe3ac0e6a57d6dc674f39e47a0"
+      }
+    },
+    "host192_independently_verified_pair_count": 21,
+    "independent_adjudication": {
+      "pair_path": "native86-main166-pair-adjudication.jsonl",
+      "pair_sha256": "f55be6435dd7ff90dd04777f693299e73a2ef42fdf0e59f58eb3f1aa247e8aab",
+      "path": "native86-main166-independent-adjudication.json",
+      "sha256": "ada06b5191e0edf92c862c68bb21562e7d46fbef014e71fb775a1b2b44dcf004",
+      "status": "partial_verification_blocked",
+      "status_counts": {
+        "independently_adjudicated": 773,
+        "not_independently_adjudicated_missing_expected_gate_artifact": 147
+      }
+    },
+    "legacy_dbp_medium_posts_timing": {
+      "admitted_dataset_result_rows": 6,
+      "independent_review": {
+        "path": "legacy-dbp-medium-posts-independent-review.json",
+        "sha256": "ec4095da7f99aebc07a4768cef15cba713a1b9e68a03d7ce41b23a9e7da3e5fd",
+        "source_sha256": "a200679cddddd96e7bd7488d499dcdeace7f098195e8ead502f70dc49af49043"
+      },
+      "receipt": {
+        "path": "legacy-dbp-medium-posts-timing-receipt.json",
+        "sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+        "source_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324"
+      }
+    },
+    "main_dataset_result_count": 25443,
+    "main_numeric_aggregate_count": 290745,
+    "main_numeric_pair_count": 11164,
+    "main_timing_proof": {
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "path": "native86-main166-timing-proof.json",
+      "schema": "paper164-old-main166-timing-provenance-readonly-v1",
+      "sha256": "f0f502d348fa20f336911f960efb63da07ddfbe922327acc636554e36d62590c",
+      "status": "passed"
+    },
+    "omitted_unresolved_pair_count": 1,
+    "pair_shape_counts": {
+      "all_na": 2274,
+      "all_numeric_ok": 9456,
+      "mixed_numeric_ok_and_na": 1708,
+      "terminal_problem_complete_with_failures": 431,
+      "terminal_problem_failed": 71
+    },
+    "profiles": {
+      "cpp-native166-main-458a218f": {
+        "aggregate_count": 290745,
+        "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+        "comparison_profiles": [
+          "cpp-native166-main-458a218f"
+        ],
+        "dataset_result_count": 25443,
+        "execution_host": "166.111.68.166",
+        "pair_count": 11164,
+        "timing_profile_status": "timing_admitted_frozen_source_build_binary_boundary_bound"
+      },
+      "cpp-native166-recovery-3452a998": {
+        "aggregate_count": 2157,
+        "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 119,
+        "execution_host": "166.111.68.166",
+        "pair_count": 48,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-39dc8c5d": {
+        "aggregate_count": 1178,
+        "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 141,
+        "execution_host": "166.111.68.166",
+        "pair_count": 57,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-458a218f": {
+        "aggregate_count": 642,
+        "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 14,
+        "execution_host": "166.111.68.166",
+        "pair_count": 6,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-813812e1": {
+        "aggregate_count": 163,
+        "binary_sha256": "813812e15013991a809e82fafe710aae77e29c96fa5d2d9101d8323a9cd07e30",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "166.111.68.166",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-82297044": {
+        "aggregate_count": 39,
+        "binary_sha256": "822970447c25f2b5f18e2d750c2a9407b6a23f22cb9f59c40565273599e20fc0",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 2,
+        "execution_host": "166.111.68.166",
+        "pair_count": 1,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-9abdc80f": {
+        "aggregate_count": 1117,
+        "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 101,
+        "execution_host": "166.111.68.166",
+        "pair_count": 40,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native192-first12-3452a998": {
+        "aggregate_count": 493,
+        "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 5,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-first12-39dc8c5d": {
+        "aggregate_count": 568,
+        "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 10,
+        "execution_host": "192.168.99.20",
+        "pair_count": 4,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-first12-9abdc80f": {
+        "aggregate_count": 148,
+        "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 11,
+        "execution_host": "192.168.99.20",
+        "pair_count": 5,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-first12-bf0a069f": {
+        "aggregate_count": 66,
+        "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 3,
+        "execution_host": "192.168.99.20",
+        "pair_count": 1,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-lzg-level5-fastfalse-00f34de8": {
+        "aggregate_count": 140,
+        "binary_sha256": "00f34de8d145e114d19bc592935fe33b241394692c4a28fd9b8597d809dd3351",
+        "comparison_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-lzg-level5-fastfalse-41d0e8fc": {
+        "aggregate_count": 56,
+        "binary_sha256": "41d0e8fc01f94ffa9d2f07796f7fc1bc45a194491535ec927ef627d663f62b08",
+        "comparison_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2"
+        ],
+        "dataset_result_count": 5,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-next5-39dc8c5d": {
+        "aggregate_count": 118,
+        "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+        "comparison_profiles": [
+          "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-next5-9abdc80f": {
+        "aggregate_count": 44,
+        "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+        "comparison_profiles": [
+          "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 3,
+        "execution_host": "192.168.99.20",
+        "pair_count": 1,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-next5-bf0a069f": {
+        "aggregate_count": 118,
+        "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+        "comparison_profiles": [
+          "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      }
+    },
+    "schema": "site-native86-full-terminal-coverage-v2",
+    "status": "passed",
+    "terminal_pair_count": 13940,
+    "unresolved_problem_pair_count": 328,
+    "v9_numeric_ok_aggregate_count": 5296,
+    "v9_recovered_pair_count": 154
+  },
+  "coverage_sha256": "3ad4905aee17e3f4d9d74df2d547bf17a1d8473ec9aab52dbe9c8f11b144cf50",
+  "created_at": "2026-10-11T08:53:18.438528+00:00",
+  "data_sha256": "433a82416f865225818c96816934218cd6eb0a4b19cfc608cc5e0010b3c46eac",
+  "manifest_sha256": "1ca8bfb2effa12aa1f062f7415a84bd3722a33ee3714c703ea1883dbdea21753",
+  "recovery_reconciliation_sha256": "39f05a3195a1aeb3ad23114322b40fa91a205e5f798e1ceb7598beb91ae7c0f2",
+  "schema": "site-native86-full-matrix-integration-v2",
+  "status": "passed",
+  "terminal_matrix_sha256": "1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9",
+  "v9_current154_sha256": "f538e84dd2b4fee3c1b0d68408095fc88714eafe3ac0e6a57d6dc674f39e47a0"
+}

README.md

@@ -31,29 +31,41 @@ python3 scripts/update_site_column_means.py \
   --dbp-medium-payload-sha256 e45170a955d1cd0df50dba25f9e41f24f00fc8b559e702d59188b6cfa60c99dc \
   --dbp-medium-receipt analysis_outputs/column_mean_20261009/dbp_medium_posts_retest/measurement_receipt.json \
   --dbp-medium-receipt-sha256 10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324
+# Rebuild the complete Native86 terminal matrix. The importer verifies the
+# 13,940-pair main export, overlays the 154 current receipt-bound V9 recoveries,
+# retains the 21 independently verified server-192 pairs, and keeps host,
+# campaign, comparison contract, exact adapter, and binary identities explicit.
+python3 deploy/huggingface-compressionbenchmark/integrate_full_native86_v6.py \
+  --main-timing-proof analysis_outputs/paper164_performance_refresh_20261011/TIMING_PROVENANCE.old_main166.json
 python3 deploy/huggingface-compressionbenchmark/build_ui_payload.py
 ```
 
-Publish `README.md`, `index.html`, `style.css`, `app.js`, `ranking.js`, `reference-catalog.json`, `dataset-catalog.json`, `data.json`, `ui-data.json`, `manifest.json`, `export_results.py`, `apply_dataset_scope.py`, and `build_ui_payload.py` to the static Space. The manifest records the exact source-file identities and metric boundaries. The compact browser payload retains the full snapshot's measurements and SHA-256 identity. The reference and dataset catalogs are independent documentation payloads and do not create benchmark measurements.
+Publish the static UI and snapshot files together with `integrate_full_native86_v6.py`, `native86-coverage.json`, the compressed 13,940-pair terminal matrix, its support-aware dataset-result source, the current-154 V9 thin export, the recovery reconciliation, the main timing proof, and the partial independent-adjudication receipt. The manifest records their exact SHA-256 identities and metric boundaries. The compact browser payload retains the full snapshot's measurements and SHA-256 identity. The reference and dataset catalogs are independent documentation payloads and do not create benchmark measurements.
 
 Only measurements in the authoritative current project scope are exported. Missing metrics and missing coverage are displayed explicitly. Existing results do not imply independently verified round trips or uniform hardware environments unless those checks are recorded in the source.
 
+The reviewed 164-dataset scope contains 89 directly measured real datasets and 75 datasets derived from real observations. Fifteen entries have incomplete source provenance; the catalog exposes this limitation rather than silently treating them as fully sourced.
+
 ## Interface
 
 - Overall and per-dataset leaderboards with runtime, data-type, precision, family, and method filters
 - Sortable metrics, optional columns, and CSV download of the selected ranking
 - Compression rate versus compression/decompression cost plots
 - Dataset-level method details, snapshot provenance, and metric definitions
-- Searchable 169-dataset catalog grouped into six source categories, with explicit measurement availability and source links
-- Gold 🏆 links for the 151 datasets hosted by THULab on Hugging Face; dataset-card links open the matching selection with `?scope=169&dataset=<key>#dataset`
+- Searchable 164-dataset catalog grouped into six source categories, with explicit measurement availability and source links
+- Gold 🏆 links for the 146 datasets hosted by THULab on Hugging Face; dataset-card links open the matching selection with `?scope=164&dataset=<key>#dataset`
 - Overall composite score and average dataset Rank, with 66 valid non-negative one-decimal weight combinations, including zero weights
 - Searchable Methods documentation and a 30-family operator catalog with 102 implementation-directory entries, references, I/O contracts, examples, and status
 
-The summary dataset count and Dataset coverage denominator use the same measured dataset set for the selected runtime, data type, and dataset selection; the default Overall view has 164 measured datasets. All 169 catalog entries remain searchable and selectable in the dataset browser. Dataset coverage can differ by method and runtime; unavailable combinations show **No published measurements**, remain excluded from rankings, and are never converted to zero-valued results. The default family view selects the best measured compression-rate configuration independently for each measured dataset. Switch to **Exact configuration** to hold a configuration fixed. Runtime results stay separate.
+The summary dataset count and Dataset coverage denominator use the same measured dataset set for the selected comparison profile, data type, and dataset selection; the default Overall view has 164 measured datasets. All 164 reviewed datasets remain searchable and selectable in the dataset browser. Dataset coverage can differ by method and profile; unavailable combinations show **No published measurements**, remain excluded from rankings, and are never converted to zero-valued results. The default family view selects the lowest-rate measured exact variant independently for each dataset only when every candidate for that dataset/family has the same eligible aggregate-id set; it can therefore choose different binaries across datasets. Ambiguous support sets are omitted. Switch to **Exact configuration** to inspect each fixed variant, support hash, source profile, and binary. Native server results use host/campaign/measurement-contract comparison profiles; exact adapter and binary identities remain visible and are never merged into one configuration.
+
+The Overall score is `a × average rate + b × normalized average compression time + c × normalized average decompression time`. It is available only when displayed methods share one exact dataset/support signature. Average Rank compares methods within each matching `(dataset, eligible aggregate-id set)` cohort, applies dataset-local time normalization and fractional ties, then averages the available ranks. Missing, N/A, failed, and unlike-support rows are omitted. Coverage and candidate counts can differ; method details expose support hashes, dataset scores, ranks and candidate counts. CSV downloads include weights, support hashes, evidence status and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
+
+Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column-level evidence. If any selected dataset/configuration is backed only by aggregate timing, the method uses an arithmetic mean of its selected per-dataset ns/point values, giving every dataset equal weight. Aggregate-only dataset timing uses recorded elapsed time divided by recorded points; these records keep a zero measured-column count. Truly missing measurements remain unavailable. Method details and CSV expose the timing basis. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons stay within the same host/campaign/measurement-contract comparison profile. Finite source timings with only diagnostic provenance are published as unavailable and cannot enter time or composite rankings.
 
-The Overall score is `a × average rate + b × normalized average compression time + c × normalized average decompression time`. Time normalization is linear min–max across all eligible rows in the selected runtime, scope and row mode; an equal-time range normalizes to zero. Search, family and coverage filters only hide rows and never change the reference. Average Rank averages per-dataset composite-score ranks with dataset-local time normalization and fractional ties. Missing results are omitted. Coverage and candidate counts can differ across datasets; method details expose dataset scores, ranks and candidate counts. CSV downloads include weights, normalization bounds and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
+The server-166 terminal matrix contains all `164 × 85 = 13,940` dataset/method pairs: 11,164 main pairs have at least one numeric aggregate, 2,274 are explicit N/A, and 502 ended with problems. Current V9 contributes receipt/result/cold-SHA-bound rate and byte replacements for 154 problem identities. Server 192 contributes 21 independently pair-verified replacements; one (`weather_data_bavaria/LZG`) overlaps V9. The union therefore repairs 174 problem identities and leaves 328 unresolved, including the separately scheduled `wids2023_competition_weather_forecasting/Shrinker` sidecar. Only result rows with `status=ok` and matching fresh-cold evidence enter numeric views; mixed-support pairs have no overall row. The old main profile's timing is admitted by a frozen source/build/binary/boundary proof. V9 and server-192 timings remain unavailable until their exact variants receive independent source/build/timing-boundary proof. Legacy source-snapshot timings with unspecified host or build boundary are also unavailable to timing and composite rankings; the six receipt-bound DBP `medium_posts` rows retain admitted timing. Server-192 results remain separate from server 166.
 
-Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column-level evidence. If any selected dataset/configuration is backed only by aggregate timing, the method uses an arithmetic mean of its selected per-dataset ns/point values, giving every dataset equal weight. Aggregate-only dataset timing uses recorded elapsed time divided by recorded points; these records keep a zero measured-column count. Truly missing measurements remain unavailable. Method details and CSV expose the timing basis. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons should therefore stay within the same runtime and measurement contract.
+The independent evidence review covers 773 archived strict-admission pairs. Its 147 non-adjudicated entries belong to the earlier 920-pair recovery bundle and retain the explicit `partial_verification_blocked` status; the site does not generalize that review to all 13,940 terminal pairs.
 
 Source project: https://github.com/xjz17/web_compression
 

app.js

@@ -1,4 +1,4 @@
-import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261009-zero-weights-v1';
+import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261011-support-matched-v1';
 const $ = (id) => document.getElementById(id);
 const escape = (value) => String(value ?? '').replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
 const number = (v) => v != null && Number.isFinite(Number(v)) ? Number(v) : null;
@@ -16,7 +16,8 @@ function aggregateTime(input,key) {
 const timingLabel=mode=>({column_mean:'Equal-column arithmetic mean',dataset_mean:'Equal-dataset arithmetic mean',dataset_aggregate:'Dataset aggregate',unavailable:'Not reported'}[mode]??'Not reported');
 const fmt = (v, digits=3) => number(v) === null ? 'Not reported' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
 const countFmt = (v) => Number(v).toLocaleString('en-US');
-const runtimeName = (v) => ({cpp:'C++',java:'Java',python:'Python'}[v] || v);
+const runtimeName = (v) => snapshot?.benchmark?.runtime_labels?.[v] || ({cpp:'C++',java:'Java',python:'Python','cpp-native166':'Native C++ · server 166','cpp-native192':'Native C++ · server 192'}[v] || v);
+const runtimeHost = (v) => snapshot?.benchmark?.runtime_hosts?.[v] || ({'cpp-native166':'166','cpp-native192':'192'}[v] || 'source snapshot');
 const THULAB_DATASET_PREFIX='https://huggingface.co/datasets/THULab/';
 const requestedDataset=new URLSearchParams(location.search).get('dataset')?.trim()||'';
 let requestedDatasetApplied=false;
@@ -41,17 +42,20 @@ let selectedMethod=null;
 const state = () => ({runtime:$('runtime').value,dataset:$('dataset').value,dtype:$('dtype').value,precision:$('precision').value,family:$('family').value,mode:$('row-mode').value,search:$('search').value.trim().toLowerCase(),complete:$('complete-only').checked});
 function scopeKey() { const s=state(); return s.dtype==='overall'?'overall':s.dtype==='int'?'integer':s.precision==='fixed'?'fixed_float':s.precision==='non_fixed'?'nonfixed_float':'float'; }
 function normalizeRecord(r) {
-  return { ...r,configuration:r.algorithm_variant??r.algorithm??r.method,method:r.algorithm_variant??r.algorithm??r.method,runtime:r.runtime ?? r.implementation_language ?? snapshot.benchmark?.implementation_language ?? 'cpp',
+  const sourceRuntime=r.runtime ?? r.implementation_language ?? snapshot.benchmark?.implementation_language ?? 'cpp';
+  return { ...r,configuration:r.algorithm_variant??r.algorithm??r.method,method:r.algorithm_variant??r.algorithm??r.method,source_runtime:sourceRuntime,runtime:r.comparison_profile??sourceRuntime,
     family:r.family ?? r.method_family ?? r.method ?? methods.get(r.algorithm)?.family ?? r.algorithm,
     compression_rate:number(r.compression_rate ?? r.average_compression_rate),compression_time:number(r.compression_time_ns_per_point ?? r.compression_time),decompression_time:number(r.decompression_time_ns_per_point ?? r.decompression_time),
-    original_bytes:number(r.original_size_bytes ?? r.original_bytes ?? r.originalSize),compressed_bytes:number(r.compressed_size_bytes ?? r.compressed_bytes ?? r.compressedSize) };
+    original_bytes:number(r.original_size_bytes ?? r.original_bytes ?? r.originalSize),compressed_bytes:number(r.compressed_size_bytes ?? r.compressed_bytes ?? r.compressedSize),
+    eligible_column_set_sha256:r.eligible_column_set_sha256??'legacy_snapshot_unbound',measurement_status:r.measurement_status??'legacy_published_measurement',timing_profile_status:r.timing_profile_status??'source_snapshot_timing',binary_sha256:r.binary_sha256??'unbound' };
 }
 function filteredRecords(ignoreMethod=false) {
   const s=state(), scope=scopeKey();
   let result=records.filter((r) => r.runtime===s.runtime && r.scope===scope && (s.dataset==='all'||r.dataset===s.dataset));
   if(s.mode==='family') {
-    const best=new Map();
-    for(const r of result){const key=`${r.dataset}\0${r.family}`;const prev=best.get(key);if(!prev||r.compression_rate<prev.compression_rate||(r.compression_rate===prev.compression_rate&&r.configuration.localeCompare(prev.configuration)<0))best.set(key,r);}
+    const choices=new Map(),best=new Map();
+    for(const r of result){const key=`${r.dataset}\0${r.family}`;if(!choices.has(key))choices.set(key,[]);choices.get(key).push(r);}
+    for(const [key,rows] of choices){if(new Set(rows.map(r=>r.eligible_column_set_sha256)).size!==1)continue;for(const r of rows){const prev=best.get(key);if(!prev||r.compression_rate<prev.compression_rate||(r.compression_rate===prev.compression_rate&&r.configuration.localeCompare(prev.configuration)<0))best.set(key,r);}}
     result=[...best.values()].map(r=>({...r,method:r.family}));
   }
   return ignoreMethod?result:result.filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search)));
@@ -59,10 +63,13 @@ function filteredRecords(ignoreMethod=false) {
 function coverageDatasetCount() { return new Set(filteredRecords(true).map(r=>r.dataset)).size; }
 function aggregate(input) {
   const groups=new Map();
-  for(const r of input) { if(!groups.has(r.method)) groups.set(r.method,[]); groups.get(r.method).push(r); }
+  const exact=state().mode==='configuration',familiesByConfiguration=new Map();
+  if(exact)for(const r of input){if(!familiesByConfiguration.has(r.method))familiesByConfiguration.set(r.method,new Set());familiesByConfiguration.get(r.method).add(r.family);}
+  for(const r of input) { const key=exact?`${r.family}\0${r.method}`:r.method;if(!groups.has(key)) groups.set(key,[]); groups.get(key).push(r); }
   const totalDatasets=coverageDatasetCount();
   const rows=[];
-  for(const [method,source] of groups) {
+  for(const [,source] of groups) {
+    const configuration=source[0].method,method=exact&&familiesByConfiguration.get(configuration).size>1?`${source[0].family} · ${configuration}`:configuration;
     const hasBytes=source.every(r=>r.original_bytes!==null && r.original_bytes>0 && r.compressed_bytes!==null && r.compressed_bytes>0);
     const original=hasBytes?source.reduce((s,r)=>s+r.original_bytes,0):null, compressed=hasBytes?source.reduce((s,r)=>s+r.compressed_bytes,0):null;
     rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:aggregateTime(source,'compression_time'),decompression_time:aggregateTime(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+r.timing_column_count,0),timing_aggregation:timingMode(source),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
@@ -95,10 +102,11 @@ function refresh() {
     // The exporter must publish an explicit all-float scope; never combine
     // preaggregated fixed/non-fixed metrics and call it an all-float result.
     $('results-note').textContent=`All-float measurements are not available in this snapshot. Select a precision category. ${columnCoverageNote}`;
-  } else $('results-note').textContent=`${state().mode==='family'?'Each family uses its lowest-rate measured configuration per dataset. Configurations may differ across datasets; use Exact configuration for fixed parameters.':'Each row retains one exact configuration. Lower compression rates and lower ns/point are better. Coverage counts datasets, not identical column sets.'} ${columnCoverageNote}`;
+  } else $('results-note').textContent=`${state().mode==='family'?'Each family uses its lowest-rate measured configuration only when that dataset/family has one exact support set; ambiguous support sets are omitted. Configurations may differ across datasets; use Exact configuration for fixed parameters.':'Each row retains one exact configuration and its eligible support-set hash. Lower compression rates and lower ns/point are better.'} ${columnCoverageNote}`;
   currentRows=aggregate(filteredRecords(true));
   const weights=parseWeights($('weights').value);
-  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized compress + ${weights[2].toFixed(1)} × normalized decompress. Lower is better. Time normalization: (time − minimum) / (maximum − minimum), across all measured rows in this runtime, scope and row mode. Search and visibility filters keep the reference fixed. Average Rank: mean of per-dataset score ranks with dataset-local time normalization; ties share their average position. Missing results are omitted. Dataset candidate counts differ, so compare rank coverage and inspect method details.`;
+  const comparable=currentRows.length&&currentRows.every(r=>r.workload_signature_count<=1);
+  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized compress + ${weights[2].toFixed(1)} × normalized decompress. Lower is better. ${comparable?'Composite scores use one shared dataset/support signature.':'Composite scores are withheld because the displayed methods do not share one exact dataset/support signature.'} Average Rank is computed only among rows with the same dataset and eligible aggregate-id support hash; ties share their average position. Missing, N/A, failed, and unlike-support results receive no rank. Compare rank coverage and inspect method details.`;
   const s=state(),scope=scopeKey(),measuredCount=coverageDatasetCount(),ds=s.dataset==='all'?`all ${measuredCount} measured datasets`:datasetDisplayName(s.dataset);
   $('dataset-count').textContent=countFmt(measuredCount);$('dataset-count-label').textContent='measured datasets';
   const names={overall:'available numeric measurements',integer:'integer columns',float:'floating-point columns',fixed_float:'fixed-precision float columns',nonfixed_float:'non-fixed-precision float columns'};
@@ -129,7 +137,7 @@ function showMethod(method,focus=false) {
   if(!row){selectedMethod=null;detail.hidden=true;return;}selectedMethod=method;
   const meta=methods.get(method)??methods.get(row.source[0].configuration), pipeline=meta?.operator_pipeline;
   const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
-  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>Compress ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>Decompress ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Timing average: ${escape(timingLabel(row.timing_aggregation))}. Dataset metrics below come from the published result files. Measurement boundaries, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
+  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>Compress ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>Decompress ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Timing average: ${escape(timingLabel(row.timing_aggregation))}. Dataset metrics below come from the published result files. Measurement boundaries, matched support-set hashes, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Measurement evidence</th><th>Timing profile</th><th>Source profile / binary</th><th>Support set</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td>${escape(r.measurement_status)}</td><td>${escape(r.timing_profile_status)}</td><td class="source-code">${escape(r.source_runtime)} / ${escape(String(r.binary_sha256).slice(0,16))}</td><td class="source-code">${escape(String(r.eligible_column_set_sha256).slice(0,16))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
   detail.hidden=false;$('close-detail').addEventListener('click',()=>{detail.hidden=true;selectedMethod=null;});
   if(focus){detail.scrollIntoView({block:'nearest',behavior:'auto'});detail.focus({preventScroll:true});}
 }
@@ -152,8 +160,8 @@ function renderChart() {
 function csv() {
   const quote=v=>{let text=String(v??'');if(typeof v==='string'&&/^[=+@-]/.test(text))text="'"+text;return `"${text.replace(/"/g,'""')}"`;};
   const weights=parseWeights($('weights').value);
-  const columns=['position','method','runtime','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','timing_column_count','timing_aggregation'];
-  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected runtime/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),r.timing_column_count,r.timing_aggregation].map(quote).join(','));
+  const columns=['position','method','comparison_profile','execution_host','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','source_profile_by_dataset','binary_sha256_by_dataset','eligible_column_set_sha256_by_dataset','measurement_status_by_dataset','timing_profile_status_by_dataset','timing_column_count','timing_aggregation'];
+  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,runtimeHost(r.runtime),scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected comparison profile/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_runtime]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.binary_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.eligible_column_set_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.measurement_status]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.timing_profile_status]))),r.timing_column_count,r.timing_aggregation].map(quote).join(','));
   const url=URL.createObjectURL(new Blob(['\ufeff'+[columns.join(','),...body].join('\r\n')],{type:'text/csv;charset=utf-8'}));const a=document.createElement('a');a.href=url;a.download=`THULab-compression-${state().runtime}-${scopeKey()}-${state().dataset}.csv`;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
 }
 function safeHttpUrl(value) {
@@ -243,7 +251,7 @@ function renderOperatorImplementation(entry) {
 function renderDocumentationViews() { renderMethodDocumentation();renderOperatorDocumentation(); }
 async function loadReferenceCatalog() {
   try {
-    const response=await fetch('./reference-catalog.json?v=20261009-dbp-integrated-v1',{cache:'no-cache'});
+    const response=await fetch('./reference-catalog.json?v=20261011-native-v6',{cache:'no-cache'});
     if(!response.ok)throw new Error(`Reference catalog request returned ${response.status}.`);
     const catalog=await response.json();
     if(!catalog||!Array.isArray(catalog.methods)||!Array.isArray(catalog.operators)||!Array.isArray(catalog.references))throw new Error('Reference catalog has an invalid schema.');
@@ -289,7 +297,7 @@ function renderDatasetEntry(entry,isMeasured) {
 }
 async function loadDatasetCatalog() {
   try {
-    const response=await fetch('./dataset-catalog.json?v=20261009-thulab-dataset-badge-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Dataset catalog request returned ${response.status}.`);
+    const response=await fetch('./dataset-catalog.json?v=20261011-native-v6',{cache:'no-cache'});if(!response.ok)throw new Error(`Dataset catalog request returned ${response.status}.`);
     const catalog=await response.json();if(!catalog||!Array.isArray(catalog.datasets)||!catalog.summary)throw new Error('Dataset catalog has an invalid schema.');datasetCatalog=catalog;
   } catch(error) { datasetCatalogError=error instanceof Error?error:new Error('Dataset catalog is unavailable.'); }
   if(snapshot){populateDatasetControls();renderDatasetCatalog();renderAbout();}
@@ -301,16 +309,18 @@ function renderAbout() {
   const definitions=b.metric_definitions||{};if(Object.keys(definitions).length)$('methodology').innerHTML+=`<dl class="definitions">${Object.entries(definitions).map(([k,v])=>`<div><dt>${escape(k.replaceAll('_',' '))}</dt><dd>${escape(typeof v==='string'?v:JSON.stringify(v))}</dd></div>`).join('')}</dl>`;
   const exclusions=c.exclusions||c.excluded_datasets||snapshot.exclusions||[];
   const catalogCount=number(datasetCatalog?.summary?.dataset_count??c.catalog_dataset_count)??datasetEntries().length,measuredCount=number(datasetCatalog?.summary?.published_result_dataset_count??datasetCatalog?.summary?.published_measurement_dataset_count??datasetCatalog?.summary?.measured_dataset_count??c.measured_dataset_count)??new Set(records.map(r=>r.dataset)).size;
-  const info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Not reported','Dataset catalog':`${catalogCount} datasets; ${measuredCount} currently have published measurements and participate in rankings`,'Dataset scope generated':s.generated_at||'Not reported', 'Source checkout':s.git_commit||'Not reported','Source files':`${s.source_files?.length??0} metadata inputs and ${s.result_csv_files_used?.length??0} result CSVs (hashes in manifest)`,'Result entries across scopes':`${records.length} (scope slices can reuse a measurement)`,'Worktree source state':s.worktree_dirty_inputs?.length?'Includes current local changes; input file hashes identify the published snapshot.':'See manifest for source file hashes.','Runtime environment':b.hardware||'Hardware details are not recorded in this exported result snapshot.','Lossless evidence':b.roundtrip_evidence||'Lossless-design method filter from the source project; per-run round-trip verification is not recorded here.'};
+  const terminal=c.native86_terminal_coverage||{};
+  const info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Not reported','Dataset catalog':`${catalogCount} datasets; ${measuredCount} currently have published measurements and participate in rankings`,'Native86 server-166 terminal matrix':terminal.expected_pair_count?`${terminal.observed_pair_count} / ${terminal.expected_pair_count} dataset-method pairs; ${terminal.numeric_pair_count??0} contain published numeric aggregates, ${terminal.not_applicable_pair_count??0} are explicit N/A, ${terminal.problem_pair_count??0} ended with a failure status`:'See manifest and terminal coverage download','Dataset scope generated':s.generated_at||'Not reported', 'Source checkout':s.git_commit||'Not reported','Source files':`${s.source_files?.length??0} metadata inputs and ${s.result_csv_files_used?.length??0} result CSVs (hashes in manifest)`,'Result entries across scopes':`${records.length} (scope slices can reuse a measurement)`,'Worktree source state':s.worktree_dirty_inputs?.length?'Includes current local changes; input file hashes identify the published snapshot.':'See manifest for source file hashes.','Runtime environment':b.hardware||'Hardware details are not recorded in this exported result snapshot.','Lossless evidence':b.roundtrip_evidence||'Lossless-design method filter from the source project; per-run round-trip verification is not recorded here.'};
   $('provenance').innerHTML=`<table class="provenance-table"><tbody>${Object.entries(info).map(([k,v])=>`<tr><th>${escape(k)}</th><td class="source-code">${escape(v)}</td></tr>`).join('')}</tbody></table>${exclusions.length?`<h3>Excluded or unavailable results</h3><p class="source-code">${escape(typeof exclusions==='string'?exclusions:JSON.stringify(exclusions))}</p>`:''}`;
 }
 function init() {
-  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],family:t.families[r[3]],method:t.configurations[r[4]],algorithm_variant:t.configurations[r[4]],compression_rate:r[5],compression_time_ns_per_point:r[6],decompression_time_ns_per_point:r[7],original_size_bytes:r[8],compressed_size_bytes:r[9],timing_column_count:r[10],timing_aggregation:t.timing_aggregations[r[11]]}));delete snapshot.compact_records;}
+  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],comparison_profile:t.comparison_profiles[r[3]],family:t.families[r[4]],method:t.configurations[r[5]],algorithm_variant:t.configurations[r[5]],compression_rate:r[6],compression_time_ns_per_point:r[7],decompression_time_ns_per_point:r[8],original_size_bytes:r[9],compressed_size_bytes:r[10],timing_column_count:r[11],timing_aggregation:t.timing_aggregations[r[12]],eligible_column_set_sha256:t.support_sets[r[13]],measurement_status:t.measurement_statuses[r[14]],timing_profile_status:t.timing_statuses[r[15]],binary_sha256:t.binary_hashes[r[16]]}));delete snapshot.compact_records;}
   for(const m of snapshot.methods||[]) { const method=typeof m==='string'?{name:m}:m;methods.set(method.name??method.method,method);for(const c of method.configurations||[])methods.set(c.algorithm_variant,{...method,name:c.algorithm_variant,family:method.name}); }
   for(const d of snapshot.datasets||[])datasets.set(d.key??d.dataset,d);
   records=(snapshot.dataset_results||snapshot.records||[]).map(normalizeRecord).filter(r=>r.method&&r.dataset&&r.compression_rate>0);
   for(const r of records)if(!methods.has(r.method))methods.set(r.method,{name:r.method,family:r.family});
-  const runtimes=[...new Set(records.map(r=>r.runtime))].sort((a,b)=>['cpp','java','python'].indexOf(a)-['cpp','java','python'].indexOf(b));
+  const runtimeOrder=['cpp','java','python'];
+  const runtimes=[...new Set(records.map(r=>r.runtime))].sort((a,b)=>{const ai=runtimeOrder.indexOf(a),bi=runtimeOrder.indexOf(b);return (ai<0?runtimeOrder.length:ai)-(bi<0?runtimeOrder.length:bi)||a.localeCompare(b);});
   $('runtime').innerHTML=runtimes.map(r=>`<option value="${escape(r)}">${escape(runtimeName(r))}</option>`).join('');
   populateDatasetControls();
   $('family').innerHTML='<option value="all">All method families</option>'+[...new Set(records.map(r=>r.family))].sort().map(f=>`<option value="${escape(f)}">${escape(f)}</option>`).join('');
@@ -343,5 +353,5 @@ function setupTheme() {
 setupTheme();
 void loadReferenceCatalog();
 void loadDatasetCatalog();
-try { const response=await fetch('./ui-data.json?v=20261009-thulab-dataset-badge-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
+try { const response=await fetch('./ui-data.json?v=20261011-native-v6',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
 catch(e){$('load-error').hidden=false;$('load-error').textContent=`The result snapshot could not be loaded. Please reload the page or download the JSON from the repository. ${e.message}`;$('snapshot').textContent='Snapshot unavailable';$('leaderboard').querySelector('tbody').innerHTML='<tr><td class="empty-cell">Results unavailable.</td></tr>';}

apply_dataset_scope.py

@@ -1,4 +1,4 @@
-"""Apply the public dataset catalog to an existing measured snapshot.
+"""Apply the reviewed 164-dataset public scope to a measured snapshot.
 
 This is a scope filter, not a benchmark runner: retained individual measurements
 are copied unchanged, excluded measurements are removed, and aggregates are
@@ -16,6 +16,73 @@ from export_results import _aggregate_rows
 
 ROOT = Path(__file__).resolve().parent
 
+# These five catalog-only entries were absent from the deployed leaderboard's
+# effective measured scope.  Keep the public benchmark fixed to the reviewed
+# 164 real datasets even if a later input catalog happens to contain them.
+OUTSIDE_WEBSITE164_SCOPE = frozenset({
+    "app_flow",
+    "ethereum_signals_sample",
+    "github_top_developers",
+    "tiktok_trending_hashtags_music",
+    "youtube_trending_2019_2020",
+})
+
+
+def _is_glza(row: dict) -> bool:
+    return str(row.get("family", "")).casefold() == "glza" or "glza" in str(
+        row.get("method", "")
+    ).casefold()
+
+
+def _contains_glza(value: object) -> bool:
+    if isinstance(value, dict):
+        return any("glza" in str(key).casefold() or _contains_glza(item)
+                   for key, item in value.items())
+    if isinstance(value, list):
+        return any(_contains_glza(item) for item in value)
+    return "glza" in str(value).casefold()
+
+
+def _filter_reference_catalog(path: Path) -> str:
+    """Remove the excluded method from every public documentation domain."""
+    catalog = json.loads(path.read_text())
+    removed = [item for item in catalog.get("methods", []) if _is_glza(item)]
+    catalog["methods"] = [
+        item for item in catalog.get("methods", []) if not _is_glza(item)
+    ]
+    source = catalog.setdefault("source", {})
+    removed.extend(item for item in source.get("ppt_method_aliases", []) if _is_glza(item))
+    source["ppt_method_aliases"] = [
+        item for item in source.get("ppt_method_aliases", []) if not _is_glza(item)
+    ]
+    removed.extend(item for item in source.get("additional_measured_families", []) if _is_glza(item))
+    source["additional_measured_families"] = [
+        item for item in source.get("additional_measured_families", []) if not _is_glza(item)
+    ]
+    removed_reference_ids = {
+        str(value) for item in removed for value in item.get("reference_ids", [])
+    }
+    referenced = set()
+    for item in catalog.get("methods", []) + catalog.get("operators", []):
+        referenced.update(str(value) for value in item.get("reference_ids", []))
+        for implementation in item.get("implementations", []):
+            referenced.update(str(value) for value in implementation.get("reference_ids", []))
+    for item in source.get("ppt_method_aliases", []) + source.get("additional_measured_families", []):
+        referenced.update(str(value) for value in item.get("reference_ids", []))
+    catalog["references"] = [
+        item for item in catalog.get("references", [])
+        if not (
+            str(item.get("id")) in removed_reference_ids
+            and str(item.get("id")) not in referenced
+        ) and not _contains_glza(item)
+    ]
+    if _contains_glza(catalog):
+        raise ValueError("GLZA remains in the filtered public reference catalog")
+    path.write_text(
+        json.dumps(catalog, ensure_ascii=False, indent=2, allow_nan=False) + "\n"
+    )
+    return sha(path)
+
 
 def sha(path: Path) -> str:
     return hashlib.sha256(path.read_bytes()).hexdigest()
@@ -26,14 +93,29 @@ def apply() -> None:
     catalog = json.loads(catalog_path.read_text())
     data_path = ROOT / "data.json"
     data = json.loads(data_path.read_text())
+    reference_catalog_path = ROOT / "reference-catalog.json"
+    reference_catalog_sha256 = _filter_reference_catalog(reference_catalog_path)
+    original_catalog = list(catalog["datasets"])
+    original_keys = {d["key"] for d in original_catalog}
+    if len(original_keys) != len(original_catalog):
+        raise ValueError("The public catalog contains duplicate dataset keys")
+    if len(original_keys) == 169 and not OUTSIDE_WEBSITE164_SCOPE <= original_keys:
+        raise ValueError("The 169-dataset catalog does not identify the website164 exclusions")
+    if len(original_keys) == 164 and original_keys & OUTSIDE_WEBSITE164_SCOPE:
+        raise ValueError("The 164-dataset catalog still contains an excluded catalog-only dataset")
+    if len(original_keys) not in {164, 169}:
+        raise ValueError(f"Expected a 164- or 169-dataset input catalog, found {len(original_keys)}")
+    catalog["datasets"] = [
+        item for item in original_catalog if item["key"] not in OUTSIDE_WEBSITE164_SCOPE
+    ]
     allowed = {d["key"] for d in catalog["datasets"]}
-    if len(allowed) != 169 or len(catalog["datasets"]) != 169:
-        raise ValueError("The reviewed public catalog must contain 169 unique datasets")
+    if len(allowed) != 164 or len(catalog["datasets"]) != 164:
+        raise ValueError(f"The reviewed public scope must contain 164 unique datasets, found {len(allowed)}")
     excluded = {d["key"] for d in catalog.get("excluded", [])}
     if allowed & excluded:
         raise ValueError("Excluded datasets are present in the public catalog")
     old_rows = data["dataset_results"]
-    rows = [r for r in old_rows if r["dataset"] in allowed]
+    rows = [r for r in old_rows if r["dataset"] in allowed and not _is_glza(r)]
     if not rows:
         raise ValueError("The snapshot has no measurements in the reviewed scope")
     measured = {r["dataset"] for r in rows}
@@ -66,18 +148,63 @@ def apply() -> None:
     # Retire the unrelated older paper aggregation instead of presenting it as
     # evidence for the new catalog scope.
     data.pop("paper_table3", None)
+    category_labels = {
+        item["category"]: item.get("category_label", item["category"])
+        for item in catalog["datasets"]
+    }
+    category_counts = {
+        key: sum(item["category"] == key for item in catalog["datasets"])
+        for key in category_labels
+    }
+    catalog["summary"].update(
+        dataset_count=164,
+        catalog_only_dataset_count=0,
+        published_result_dataset_count=len(measured),
+        published_measurement_dataset_count=len(measured),
+        empty_dataset_count=sum((item.get("row_count") or 0) == 0 for item in catalog["datasets"]),
+        legacy_count=sum(item.get("cohort") == "legacy" for item in catalog["datasets"]),
+        thulab_count=sum(item.get("cohort") == "thulab" for item in catalog["datasets"]),
+        categories=[
+            {"key": key, "label": category_labels[key], "count": category_counts[key]}
+            for key in category_labels
+        ],
+        origin_classes={
+            key: sum(item.get("origin_class") == key for item in catalog["datasets"])
+            for key in ("real_measured", "derived_from_real")
+        },
+        provenance_statuses={
+            key: sum(item.get("provenance_status") == key for item in catalog["datasets"])
+            for key in ("source_supported", "incomplete")
+        },
+        measurement_note=(
+            "The reviewed scope contains 89 real-measured and 75 derived-from-real datasets; "
+            "15 have incomplete source provenance. Availability varies by method, runtime, "
+            "and data type; missing measurements remain unavailable."
+        ),
+    )
+    catalog_path.write_text(
+        json.dumps(catalog, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n"
+    )
     data["dataset_overview"] = {
-        "dataset_count": 169, "measured_dataset_count": len(measured),
+        "dataset_count": 164, "measured_dataset_count": len(measured),
         "total_rows": sum(d.get("row_count") or 0 for d in catalog["datasets"]),
         "total_rows_available_dataset_count": sum(d.get("row_count") is not None for d in catalog["datasets"]),
-        "provenance_note": "Dataset catalog statistics follow the reviewed 169-dataset scope. Compression metrics use only published measurement rows."}
+        "provenance_note": "Dataset catalog statistics follow the reviewed 164-real-dataset scope. Compression metrics use only published measurement rows."}
     benchmark = data["benchmark"]
     benchmark.pop("paper_result_selection", None)
     benchmark["metric_definitions"] = {k: v for k, v in benchmark["metric_definitions"].items() if not k.startswith("paper_")}
     for field in ("notes", "measurement_boundaries"):
         benchmark[field] = [s for s in benchmark.get(field, []) if "paper" not in s.lower()]
-    benchmark["scope_note"] = f"The dataset catalog contains 169 reviewed datasets (18 legacy + 151 THULab). Published measurement rows currently cover {len(measured)} of them. Catalog inclusion does not imply completed experiments or full-column coverage."
-    benchmark["publication_note"] = "The new Native86 evaluation is a separate, incomplete experiment. Its partial outputs are not mixed with this published multi-runtime snapshot."
+    benchmark["scope_note"] = (
+        f"The benchmark contains 164 reviewed datasets: 89 real-measured and 75 derived-from-real; "
+        f"15 have incomplete source provenance. Published measurement rows currently cover {len(measured)} "
+        "of them. Missing combinations remain unavailable rather than zero."
+    )
+    benchmark["publication_note"] = (
+        "All Native86 rows require hash-bound matching benchmark and fresh-cold results. "
+        "The server-192 cohort also carries independent pair-verification receipts; the "
+        "server-166 cohort carries strict source/admission or fresh-cold recovery receipts."
+    )
     source = data["source"]
     source["source_files"] = [s for s in source["source_files"] if s.get("role") not in ("paper_table3", "dataset_scope", "dataset_catalog")]
     source["source_files"].append({"role": "reviewed_dataset_catalog", "path": "dataset-catalog.json", "sha256": sha(catalog_path), "status": "reviewed_public_catalog"})
@@ -86,13 +213,13 @@ def apply() -> None:
     source.setdefault("scope_input_snapshot_sha256", old_sha)
     source["scope_catalog_sha256"] = sha(catalog_path)
     coverage = data["coverage"]
-    coverage.update(dataset_count=169, catalog_dataset_count=169, measured_dataset_count=len(measured),
+    coverage.update(dataset_count=164, catalog_dataset_count=164, measured_dataset_count=len(measured),
                     dataset_result_row_count=len(rows), configuration_aggregate_row_count=len(data["configuration_aggregates"]),
                     family_best_aggregate_row_count=len(data["family_best_aggregates"]),
                     method_family_count=len({r["family"] for r in rows}), method_configuration_count=len({r["method"] for r in rows}),
                     runtime_configuration_count=len({(r["runtime"], r["method"]) for r in rows}),
                     source_report_file_count=len(source["result_csv_files_used"]), paper_leaderboard_row_count=0,
-                    excluded_datasets=sorted(excluded | set(coverage.get("excluded_datasets", []))))
+                    excluded_datasets=sorted(excluded | OUTSIDE_WEBSITE164_SCOPE | set(coverage.get("excluded_datasets", []))))
     coverage.update(
         timing_column_observation_count=sum(r.get("timing_column_count", 0) for r in rows),
         timing_column_mean_dataset_result_count=sum(
@@ -110,9 +237,10 @@ def apply() -> None:
     manifest_path = ROOT / "manifest.json"
     manifest = json.loads(manifest_path.read_text())
     manifest.update(counts=coverage, data_sha256=sha(data_path), source_files=source["source_files"],
-                    result_csv_files=source["result_csv_files_used"], dataset_catalog_sha256=sha(catalog_path))
+                    result_csv_files=source["result_csv_files_used"], dataset_catalog_sha256=sha(catalog_path),
+                    reference_catalog_sha256=reference_catalog_sha256)
     manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n")
-    print(json.dumps({"catalog_datasets": 169, "measured_datasets": len(measured), "retained_rows": len(rows),
+    print(json.dumps({"catalog_datasets": 164, "measured_datasets": len(measured), "retained_rows": len(rows),
                       "removed_rows": len(old_rows) - len(rows), "data_sha256": sha(data_path)}))
 
 

build_ui_payload.py

@@ -12,9 +12,14 @@ def build() -> None:
     data = json.loads(source.read_text())
     rows = data['dataset_results']
     fields = {'datasets': 'dataset', 'scopes': 'scope', 'runtimes': 'runtime',
-              'families': 'family', 'configurations': 'algorithm_variant'}
+              'comparison_profiles': 'comparison_profile', 'families': 'family',
+              'configurations': 'algorithm_variant'}
     tables = {key: sorted({r[field] for r in rows}) for key, field in fields.items()}
     tables['timing_aggregations'] = sorted({r['timing_aggregation'] for r in rows})
+    tables['support_sets'] = sorted({r.get('eligible_column_set_sha256', 'legacy_snapshot_unbound') for r in rows})
+    tables['measurement_statuses'] = sorted({r.get('measurement_status', 'legacy_published_measurement') for r in rows})
+    tables['timing_statuses'] = sorted({r.get('timing_profile_status', 'source_snapshot_timing') for r in rows})
+    tables['binary_hashes'] = sorted({r.get('binary_sha256') or 'unbound' for r in rows})
     indices = {key: {v:i for i,v in enumerate(values)} for key,values in tables.items()}
     compact = []
     for r in rows:
@@ -22,7 +27,11 @@ def build() -> None:
                         r['compression_rate'], r['compression_time_ns_per_point'],
                         r['decompression_time_ns_per_point'], r['original_size_bytes'],
                         r['compressed_size_bytes'], r.get('timing_column_count', 0),
-                        indices['timing_aggregations'][r['timing_aggregation']]])
+                        indices['timing_aggregations'][r['timing_aggregation']],
+                        indices['support_sets'][r.get('eligible_column_set_sha256', 'legacy_snapshot_unbound')],
+                        indices['measurement_statuses'][r.get('measurement_status', 'legacy_published_measurement')],
+                        indices['timing_statuses'][r.get('timing_profile_status', 'source_snapshot_timing')],
+                        indices['binary_hashes'][r.get('binary_sha256') or 'unbound']])
     payload = {key: data[key] for key in ('schema_version','benchmark','coverage','datasets','methods','scopes','source')}
     if 'dataset_summary' in data:
         payload['dataset_summary'] = data['dataset_summary']

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:727bf6a91dbb2bc8f63dd87122b8dc1db261589e4da742f28f0e52dad0616571
-size 41080819
+oid sha256:433a82416f865225818c96816934218cd6eb0a4b19cfc608cc5e0010b3c46eac
+size 130436188

dataset-catalog.json

@@ -720,36 +720,6 @@
       "source_url": "https://huggingface.co/datasets/kshift/ahr999-dataset",
       "value_cell_count": 12872
     },
-    {
-      "category": "web_computing",
-      "category_label": "Web & Computing",
-      "cohort": "thulab",
-      "cohort_label": "THULab dataset collection",
-      "column_count": 3,
-      "controlled_test_data": false,
-      "dataset_url": "https://huggingface.co/datasets/THULab/app_flow",
-      "has_published_results": false,
-      "key": "app_flow",
-      "label": "app_flow",
-      "measurement_eligibility": "eligible",
-      "numeric_column_count": 2,
-      "origin_class": "derived_from_real",
-      "origin_confidence": "medium",
-      "preparation_status": "ready",
-      "production_context": "unspecified_or_production_observational",
-      "provenance_status": "source_supported",
-      "published_result_row_count": null,
-      "published_result_row_count_matches_catalog": null,
-      "published_result_scope": null,
-      "row_count": 1048575,
-      "shared_metadata_bytes": 24030838,
-      "size_basis": "native_numeric_bytes_excluding_validity_and_metadata",
-      "size_bytes": 25165800,
-      "source": "Hugging Face",
-      "source_order": 25,
-      "source_url": "https://huggingface.co/datasets/kashif/App_Flow",
-      "value_cell_count": 2097150
-    },
     {
       "category": "environment_space",
       "category_label": "Environment & Space",
@@ -1530,36 +1500,6 @@
       "source_url": "https://arxiv.org/html/2602.12147v4",
       "value_cell_count": 262080
     },
-    {
-      "category": "finance_commerce",
-      "category_label": "Finance & Commerce",
-      "cohort": "thulab",
-      "cohort_label": "THULab dataset collection",
-      "column_count": 10,
-      "controlled_test_data": true,
-      "dataset_url": "https://huggingface.co/datasets/THULab/ethereum_signals_sample",
-      "has_published_results": false,
-      "key": "ethereum_signals_sample",
-      "label": "ethereum_signals_sample",
-      "measurement_eligibility": "eligible",
-      "numeric_column_count": 9,
-      "origin_class": "derived_from_real",
-      "origin_confidence": "high",
-      "preparation_status": "ready",
-      "production_context": "controlled_nonproduction_sepolia_testnet",
-      "provenance_status": "source_supported",
-      "published_result_row_count": null,
-      "published_result_row_count_matches_catalog": null,
-      "published_result_scope": null,
-      "row_count": 5988,
-      "shared_metadata_bytes": 136684,
-      "size_basis": "native_numeric_bytes_excluding_validity_and_metadata",
-      "size_bytes": 479040,
-      "source": "Hugging Face",
-      "source_order": 52,
-      "source_url": "https://huggingface.co/datasets/MikeKuykendall/ethereum-signals-sample/raw/ec73f4e659259961c5fe74c634893ae250b7aa9a/README.md",
-      "value_cell_count": 47904
-    },
     {
       "category": "energy_industry",
       "category_label": "Energy & Industry",
@@ -1860,36 +1800,6 @@
       "source_url": "https://huggingface.co/datasets/juliensimon/geomagnetic-kp-index",
       "value_cell_count": 2058
     },
-    {
-      "category": "web_computing",
-      "category_label": "Web & Computing",
-      "cohort": "thulab",
-      "cohort_label": "THULab dataset collection",
-      "column_count": 2,
-      "controlled_test_data": false,
-      "dataset_url": "https://huggingface.co/datasets/THULab/github_top_developers",
-      "has_published_results": false,
-      "key": "github_top_developers",
-      "label": "github_top_developers",
-      "measurement_eligibility": "eligible",
-      "numeric_column_count": 1,
-      "origin_class": "derived_from_real",
-      "origin_confidence": "high",
-      "preparation_status": "ready",
-      "production_context": "unspecified_or_production_observational",
-      "provenance_status": "source_supported",
-      "published_result_row_count": null,
-      "published_result_row_count_matches_catalog": null,
-      "published_result_scope": null,
-      "row_count": 39390,
-      "shared_metadata_bytes": 6942303,
-      "size_basis": "native_numeric_bytes_excluding_validity_and_metadata",
-      "size_bytes": 630240,
-      "source": "Hugging Face",
-      "source_order": 63,
-      "source_url": "https://huggingface.co/datasets/diamond-in/github-top-developers",
-      "value_cell_count": 39390
-    },
     {
       "category": "web_computing",
       "category_label": "Web & Computing",
@@ -3840,36 +3750,6 @@
       "source_url": "https://zenodo.org/record/5129073",
       "value_cell_count": 23252166
     },
-    {
-      "category": "web_computing",
-      "category_label": "Web & Computing",
-      "cohort": "thulab",
-      "cohort_label": "THULab dataset collection",
-      "column_count": 11,
-      "controlled_test_data": false,
-      "dataset_url": "https://huggingface.co/datasets/THULab/tiktok_trending_hashtags_music",
-      "has_published_results": false,
-      "key": "tiktok_trending_hashtags_music",
-      "label": "tiktok_trending_hashtags_music",
-      "measurement_eligibility": "unavailable_empty_dataset",
-      "numeric_column_count": 10,
-      "origin_class": "derived_from_real",
-      "origin_confidence": "medium",
-      "preparation_status": "ready",
-      "production_context": "unspecified_or_production_observational",
-      "provenance_status": "source_supported",
-      "published_result_row_count": null,
-      "published_result_row_count_matches_catalog": null,
-      "published_result_scope": null,
-      "row_count": 0,
-      "shared_metadata_bytes": 2765,
-      "size_basis": "native_numeric_bytes_excluding_validity_and_metadata",
-      "size_bytes": 0,
-      "source": "ads.tiktok.com",
-      "source_order": 129,
-      "source_url": "https://ads.tiktok.com/business/creativecenter/inspiration/popular/hashtag/pc/en",
-      "value_cell_count": 0
-    },
     {
       "category": "finance_commerce",
       "category_label": "Finance & Commerce",
@@ -5010,36 +4890,6 @@
       "source_url": "https://huggingface.co/datasets/czl/yongchun_public_gym",
       "value_cell_count": 212130
     },
-    {
-      "category": "web_computing",
-      "category_label": "Web & Computing",
-      "cohort": "thulab",
-      "cohort_label": "THULab dataset collection",
-      "column_count": 7,
-      "controlled_test_data": false,
-      "dataset_url": "https://huggingface.co/datasets/THULab/youtube_trending_2019_2020",
-      "has_published_results": false,
-      "key": "youtube_trending_2019_2020",
-      "label": "youtube_trending_2019_2020",
-      "measurement_eligibility": "eligible",
-      "numeric_column_count": 6,
-      "origin_class": "derived_from_real",
-      "origin_confidence": "medium",
-      "preparation_status": "ready",
-      "production_context": "unspecified_or_production_observational",
-      "provenance_status": "source_supported",
-      "published_result_row_count": null,
-      "published_result_row_count_matches_catalog": null,
-      "published_result_scope": null,
-      "row_count": 1541128,
-      "shared_metadata_bytes": 46042520,
-      "size_basis": "native_numeric_bytes_excluding_validity_and_metadata",
-      "size_bytes": 86303168,
-      "source": "Hugging Face",
-      "source_order": 168,
-      "source_url": "https://huggingface.co/datasets/jettisonthenet/timeseries_trending_youtube_videos_2019-04-15_to_2020-04-15",
-      "value_cell_count": 9246768
-    },
     {
       "category": "finance_commerce",
       "category_label": "Finance & Commerce",
@@ -5142,22 +4992,22 @@
     "source_scope_sha256": "7ec5714939750c0551371d52e593685e3c4226681a4283af0a4d5b8abea64cfd"
   },
   "summary": {
-    "catalog_only_dataset_count": 5,
+    "catalog_only_dataset_count": 0,
     "categories": [
       {
-        "count": 61,
-        "key": "finance_commerce",
-        "label": "Finance & Commerce"
+        "count": 36,
+        "key": "environment_space",
+        "label": "Environment & Space"
       },
       {
-        "count": 24,
-        "key": "energy_industry",
-        "label": "Energy & Industry"
+        "count": 15,
+        "key": "health_society",
+        "label": "Health & Society"
       },
       {
-        "count": 36,
-        "key": "environment_space",
-        "label": "Environment & Space"
+        "count": 14,
+        "key": "web_computing",
+        "label": "Web & Computing"
       },
       {
         "count": 15,
@@ -5165,21 +5015,30 @@
         "label": "Transport & Mobility"
       },
       {
-        "count": 15,
-        "key": "health_society",
-        "label": "Health & Society"
+        "count": 60,
+        "key": "finance_commerce",
+        "label": "Finance & Commerce"
       },
       {
-        "count": 18,
-        "key": "web_computing",
-        "label": "Web & Computing"
+        "count": 24,
+        "key": "energy_industry",
+        "label": "Energy & Industry"
       }
     ],
-    "dataset_count": 169,
-    "empty_dataset_count": 1,
+    "dataset_count": 164,
+    "empty_dataset_count": 0,
     "legacy_count": 18,
-    "measurement_note": "The catalog contains 169 reviewed datasets; published measurements cover 164. Availability varies by method, runtime, and data type. Missing measurements remain unavailable.",
+    "measurement_note": "The reviewed scope contains 89 real-measured and 75 derived-from-real datasets; 15 have incomplete source provenance. Availability varies by method, runtime, and data type; missing measurements remain unavailable.",
+    "origin_classes": {
+      "derived_from_real": 75,
+      "real_measured": 89
+    },
+    "provenance_statuses": {
+      "incomplete": 15,
+      "source_supported": 149
+    },
+    "published_measurement_dataset_count": 164,
     "published_result_dataset_count": 164,
-    "thulab_count": 151
+    "thulab_count": 146
   }
 }

index.html

@@ -7,7 +7,7 @@
   <meta name="color-scheme" content="light dark">
   <title>THULab | Time Series Compression Benchmark</title>
   <link rel="stylesheet" href="style.css?v=20261009-thulab-dataset-badge-v1">
-  <script src="app.js?v=20261009-thulab-dataset-badge-v1" type="module"></script>
+  <script src="app.js?v=20261011-native-v6-full-matrix" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>
@@ -25,8 +25,8 @@
     <div class="summary-strip" id="summary" aria-label="Snapshot coverage">
       <div><strong id="dataset-count">…</strong><span id="dataset-count-label">measured datasets</span></div>
       <div><strong id="method-count">…</strong><span>method families</span></div>
-      <div><strong id="runtime-count">…</strong><span>implementation runtimes</span></div>
-      <div><strong id="record-count">…</strong><span>runtime / codec configurations</span></div>
+      <div><strong id="runtime-count">…</strong><span>comparison profiles</span></div>
+      <div><strong id="record-count">…</strong><span>profile / codec configurations</span></div>
     </div>
     <nav class="tabs" aria-label="Benchmark views">
       <button id="tab-overall" class="tab active" data-tab="overall" aria-current="page">🏅 Overall</button>
@@ -50,7 +50,7 @@
         <div id="dataset-catalog" class="dataset-catalog"></div>
       </section>
       <div class="filters" id="filters">
-        <label>Runtime<select id="runtime"></select></label>
+        <label>Comparison profile<select id="runtime"></select></label>
         <label>Data type<select id="dtype"><option value="overall">Available numeric</option><option value="int">Integer</option><option value="float">Floating point</option></select></label>
         <label>Float precision<select id="precision"><option value="all">All precision</option><option value="fixed">Fixed precision</option><option value="non_fixed">Non-fixed precision</option></select></label>
         <label>Dataset<select id="dataset"><option value="all">All datasets</option></select></label>
@@ -108,17 +108,17 @@
       <dl class="definitions">
         <div><dt>Average compression rate ↓</dt><dd>Arithmetic mean of the per-dataset compression rates in the selected scope.</dd></div>
         <div><dt>Overall compression rate ↓</dt><dd>Total compressed bytes divided by total original bytes over the selected measured records.</dd></div>
-        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column timings. If any selected dataset/configuration has only aggregate timing, use the arithmetic mean of the selected datasets' ns/point values instead, giving each dataset equal weight. For an aggregate-only dataset, ns/point comes from its recorded total elapsed time divided by its recorded point count. Truly missing measurements remain unavailable. Method details and CSV identify the timing basis. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Compare timings within the same runtime and measurement contract.</dd></div>
+        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with admitted column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column timings. If any selected dataset/configuration has only aggregate timing, use the arithmetic mean of the selected datasets' ns/point values instead, giving each dataset equal weight. For an aggregate-only dataset, ns/point comes from its recorded total elapsed time divided by its recorded point count. Missing and diagnostic-only timings remain unavailable. Method details and CSV identify the timing basis, exact source profile, and binary. Compare timings within the same host/campaign/measurement-contract profile.</dd></div>
         <div><dt>Coverage</dt><dd>Datasets with usable measurements for a method out of the measured datasets in the selected runtime, data type, and dataset selection. The summary dataset count uses the same selection. Missing results are never filled with zero.</dd></div>
-        <div><dt>Composite score ↓</dt><dd>a × average compression rate + b × normalized average compression time + c × normalized average decompression time. Each time uses min–max over all measured rows in the selected runtime, scope and row mode, before search, family and coverage filters. If all times are equal, their normalized value is zero. All measured inputs must have usable timing metrics.</dd></div>
-        <div><dt>Average Rank ↓</dt><dd>Compute the same weighted score within each dataset, normalizing times within that dataset. Rank lower scores first; ties share their average position. Then take the arithmetic mean of the method's available dataset ranks. Weights are non-negative tenths summing to 1.0. Missing measurements do not receive ranks.</dd></div>
+        <div><dt>Composite score ↓</dt><dd>a × average compression rate + b × normalized average compression time + c × normalized average decompression time. A composite is published only when the displayed methods share one exact dataset and eligible aggregate-id support signature. If all times are equal, their normalized value is zero. All measured inputs must have usable timing metrics.</dd></div>
+        <div><dt>Average Rank ↓</dt><dd>Compute the same weighted score only among methods with the same dataset and eligible aggregate-id support hash, normalizing times inside that matched cohort. Rank lower scores first; ties share their average position. Then take the arithmetic mean of the method's available matched-cohort ranks. Weights are non-negative tenths summing to 1.0. Missing, N/A, failed, and unlike-support measurements do not receive ranks.</dd></div>
       </dl>
       <h3>Reading the rankings</h3>
-      <p>Methods with different coverage are measured on different inputs. Coverage counts datasets, not identical columns or point counts. Use the full-coverage filter and inspect a single dataset's input sizes before drawing a direct comparison. Runtime filters keep Python, C++, and Java measurements separate.</p>
-      <p>By default, each family uses its measured configuration with the lowest compression rate in each dataset. The chosen configuration can vary by dataset. Switch Method rows to Exact configuration to compare a fixed configuration; method details show the exact variant used.</p>
-      <p>These are published measurements, not experiments executed inside this Space. A reported ratio alone does not establish lossless reconstruction; round-trip checks and hardware details are shown only when their evidence exists in the source snapshot.</p>
+      <p>Methods with different coverage are measured on different inputs. Coverage counts datasets, not identical columns or point counts. Use the full-coverage filter and inspect a single dataset's input sizes before drawing a direct comparison. Comparison profiles keep languages, hosts, campaigns, and measurement contracts separate.</p>
+      <p>By default, each family selects the lowest-rate exact variant independently for each dataset only when all candidates for that dataset/family have one exact support set. This view can choose different binaries across datasets. Ambiguous support sets are omitted. Switch Method rows to Exact configuration to inspect fixed variants, source profiles, binaries, and support hashes.</p>
+      <p>These are published measurements, not experiments executed inside this Space. A reported ratio alone does not establish lossless reconstruction; round-trip checks and hardware details are shown only when their evidence exists in the source snapshot. Timings without an exact admitted source/build/binary/boundary chain are unavailable to timing and composite rankings.</p>
       <h3>Download and provenance</h3>
-      <p><a href="data.json" download>Result snapshot (JSON)</a> · <a href="manifest.json" download>Source manifest (JSON)</a></p>
+      <p><a href="data.json" download>Result snapshot (JSON)</a> · <a href="manifest.json" download>Source manifest (JSON)</a> · <a href="native86-coverage.json" download>Native86 coverage summary (JSON)</a> · <a href="native86-terminal-matrix.jsonl.gz" download>13,940-pair terminal matrix (JSONL.GZ)</a> · <a href="native86-v9-current154-thin.jsonl.gz" download>Current 154-pair V9 evidence (JSONL.GZ)</a> · <a href="native86-recovery-reconciliation.json" download>Recovery reconciliation (JSON)</a></p>
       <div id="provenance"></div>
       <h3>Contribute a result</h3>
       <p>Run the project benchmark and provide the codec/configuration, input identity, compression and decompression measurements, execution environment, and round-trip validation evidence. Results can be updated from the source project using the snapshot exporter included in the Space repository.</p>

integrate_full_native86_v6.py

@@ -0,0 +1,1078 @@
+#!/usr/bin/env python3
+"""Build the website Native86 view from the complete terminal matrix.
+
+This importer keeps three boundaries explicit:
+
+* the server-166 main campaign terminal matrix is complete, including N/A and
+  failed pairs, while only receipt-ok numeric rows enter the leaderboard;
+* V9 repairs replace only their failed main identities and retain a distinct
+  campaign/binary runtime profile;
+* server-192 results retain their independently verified campaign/binary
+  profiles and are never pooled with server-166 timings.
+
+All numeric rows are tied to a sorted eligible aggregate-id SHA-256.  Mixed
+support pairs never receive a synthetic overall row.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import gzip
+import hashlib
+import json
+import math
+import shutil
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+
+from export_results import _aggregate_rows
+from integrate_native86_results import profile_pairs, read_json, read_jsonl, require_hash, sha256
+
+
+MAIN_BINARY = "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664"
+HOST166 = "166.111.68.166"
+HOST192 = "192.168.99.20"
+DBP_MEDIUM_RECEIPT_SHA = "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324"
+DBP_MEDIUM_INDEPENDENT_SHA = "a200679cddddd96e7bd7488d499dcdeace7f098195e8ead502f70dc49af49043"
+EXPECTED_MAIN_SHAPES = {
+    "all_numeric_ok": 9456,
+    "mixed_numeric_ok_and_na": 1708,
+    "all_na": 2274,
+    "terminal_problem_complete_with_failures": 431,
+    "terminal_problem_failed": 71,
+}
+
+
+def canonical_sha(values: Iterable[str]) -> str:
+    payload = json.dumps(sorted(values), ensure_ascii=False, separators=(",", ":"))
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def public_path(path: Path, root: Path) -> str:
+    try:
+        return path.resolve().relative_to(root.resolve()).as_posix()
+    except ValueError:
+        return path.name
+
+
+def sanitize_local_paths(value: Any, checkout: Path) -> Any:
+    """Remove workstation-specific checkout prefixes from public evidence."""
+    if isinstance(value, dict):
+        return {key: sanitize_local_paths(item, checkout) for key, item in value.items()}
+    if isinstance(value, list):
+        return [sanitize_local_paths(item, checkout) for item in value]
+    if isinstance(value, str):
+        prefix = checkout.resolve().as_posix().rstrip("/") + "/"
+        return "source-checkout/" + value[len(prefix):] if value.startswith(prefix) else value
+    return value
+
+
+def read_gzip_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with gzip.open(path, "rt", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            value = json.loads(line)
+            if not isinstance(value, dict):
+                raise ValueError(f"Expected object at {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def finite(value: Any, *, positive: bool = False) -> float:
+    number = float(value)
+    if not math.isfinite(number) or (positive and number <= 0):
+        raise ValueError(f"Invalid numeric value: {value!r}")
+    return number
+
+
+def dtype_scope(dtype: str) -> str:
+    value = dtype.casefold()
+    if value.startswith("float"):
+        return "float"
+    if value.startswith("int") or value.startswith("uint"):
+        return "integer"
+    raise ValueError(f"Unsupported Native86 dtype: {dtype}")
+
+
+def runtime_key(host: str, campaign: str, binary_sha: str) -> str:
+    label = campaign.lower().replace("_", "-")
+    return f"cpp-native{host}-{label}-{binary_sha[:8]}"
+
+
+def profile_slug(value: Any) -> str:
+    return "".join(character if character.isalnum() else "-" for character in str(value).lower()).strip("-")
+
+
+def first_profile_version(results: list[dict[str, Any]]) -> str:
+    versions = {str(row.get("profile_version") or "unspecified-profile") for row in results}
+    if len(versions) != 1:
+        raise ValueError(f"One verified pair contains multiple profile versions: {sorted(versions)}")
+    return profile_slug(next(iter(versions)))
+
+
+def legacy_support_sha(row: dict[str, Any]) -> str:
+    # Legacy CSV exports do not retain aggregate ids.  This hash is explicitly
+    # a scope-contract identity, not a claim that individual columns were bound.
+    return canonical_sha(["legacy-export-scope-contract", str(row["dataset"]), str(row["scope"])])
+
+
+def verify_legacy_dbp_timing(
+    receipt_path: Path, independent_path: Path,
+) -> dict[str, Any]:
+    require_hash(receipt_path, DBP_MEDIUM_RECEIPT_SHA, "DBP medium_posts timing receipt")
+    require_hash(independent_path, DBP_MEDIUM_INDEPENDENT_SHA, "DBP medium_posts independent review")
+    receipt = read_json(receipt_path)
+    independent = read_json(independent_path)
+    if (
+        receipt.get("schema") != "dbp-medium-posts-retest-receipt-v2"
+        or receipt.get("status") != "passed"
+        or receipt.get("dataset") != "medium_posts"
+        or receipt.get("scope") != "integer"
+        or receipt.get("benchmark_contract", {}).get("timing_aggregation") != "column_mean"
+        or independent.get("schema") != "dbp-medium-posts-independent-audit-v1"
+        or independent.get("status") != "passed"
+        or independent.get("measurement_receipt_sha256") != DBP_MEDIUM_RECEIPT_SHA
+    ):
+        raise ValueError("DBP medium_posts timing evidence is not admitted")
+    runtime_binaries = {
+        "cpp": receipt["build"]["cpp_binary"]["sha256"],
+        "java": receipt["build"]["java_main_class"]["sha256"],
+        "python": receipt["runner_files"]["dbp_int_python.py"]["sha256"],
+    }
+    expected = independent.get("measurement", {}).get("runtime_results", {})
+    if set(runtime_binaries) != set(expected) or any(len(value) != 64 for value in runtime_binaries.values()):
+        raise ValueError("DBP medium_posts evidence lacks exact runtime artifacts")
+    return {
+        "receipt_path": receipt_path,
+        "independent_path": independent_path,
+        "runtime_binaries": runtime_binaries,
+        "runtime_results": expected,
+    }
+
+
+def annotate_legacy(rows: list[dict[str, Any]], dbp_timing: dict[str, Any]) -> None:
+    for row in rows:
+        row["comparison_profile"] = str(row["runtime"])
+        row["eligible_column_set_sha256"] = legacy_support_sha(row)
+        row["eligible_dtype_scope"] = str(row["scope"])
+        row["eligible_column_set_status"] = "legacy_export_scope_contract_not_column_bound"
+        row["measurement_status"] = "legacy_published_measurement_scope_not_column_bound"
+        admitted_dbp_medium = (
+            row.get("dataset") == "medium_posts"
+            and row.get("family") == "DBP"
+            and row.get("method") == "DELTA_BINARY_PACKED"
+            and row.get("runtime") in dbp_timing["runtime_binaries"]
+            and row.get("scope") in {"integer", "overall"}
+        )
+        if admitted_dbp_medium:
+            runtime = str(row["runtime"])
+            expected = dbp_timing["runtime_results"][runtime]
+            for field in ("compression_time_ns", "decompression_time_ns",
+                          "compression_time_ns_per_point", "decompression_time_ns_per_point"):
+                if not math.isclose(finite(row[field]), finite(expected[field]), rel_tol=1e-12, abs_tol=0.0):
+                    raise ValueError(f"DBP medium_posts {runtime} timing drifted: {field}")
+            row["measurement_status"] = "rate_and_timing_admitted_dbp_medium_posts_receipt_bound"
+            row["timing_profile_status"] = "timing_admitted_dbp_medium_posts_source_build_binary_boundary_bound"
+            row["binary_sha256"] = dbp_timing["runtime_binaries"][runtime]
+            # The receipt-bound retest is an exact implementation identity.
+            # Keep it distinct from the historical unbound DBP rows sharing
+            # the same human configuration label in this runtime profile.
+            row["algorithm_variant"] = (
+                f"{row['algorithm_variant']} [{row['binary_sha256'][:8]}]"
+            )
+            row["eligible_column_set_sha256"] = canonical_sha(["medium_posts|timestamp|published"])
+            row["eligible_column_set_status"] = "exact_single_aggregate_id_sha256"
+            row["timing_receipt_sha256"] = DBP_MEDIUM_RECEIPT_SHA
+            row["timing_independent_review_sha256"] = DBP_MEDIUM_INDEPENDENT_SHA
+            continue
+        if row.get("family") in {"DBP", "REGER"} and "diagnostic_timing" not in row:
+            row["diagnostic_timing"] = {
+                "compression_time_ns": row.get("compression_time_ns"),
+                "decompression_time_ns": row.get("decompression_time_ns"),
+                "compression_time_ns_per_point": row.get("compression_time_ns_per_point"),
+                "decompression_time_ns_per_point": row.get("decompression_time_ns_per_point"),
+                "timing_column_count": row.get("timing_column_count", 0),
+                "timing_aggregation": row.get("timing_aggregation", "unavailable"),
+                "reason": "source_snapshot_host_or_exact_build_boundary_not_bound_for_ranking",
+            }
+        row["compression_time_ns"] = None
+        row["decompression_time_ns"] = None
+        row["compression_time_ns_per_point"] = None
+        row["decompression_time_ns_per_point"] = None
+        row["timing_column_count"] = 0
+        row["timing_aggregation"] = "unavailable"
+        row["timing_profile_status"] = "timing_diagnostic_source_snapshot_host_or_build_boundary_unbound_not_ranked"
+        row["binary_sha256"] = "unbound"
+
+
+def verify_main_timing_proof(path: Path | None) -> dict[str, Any] | None:
+    if path is None:
+        return None
+    proof = read_json(path)
+    if proof.get("status") not in {"passed", "verified", "admitted"}:
+        raise ValueError("Main timing proof is not admitted")
+    blob = json.dumps(proof, sort_keys=True)
+    if MAIN_BINARY not in blob:
+        raise ValueError("Main timing proof does not bind the expected binary")
+    required_tokens = ("source", "build", "warmup", "repeat", "timing")
+    if any(token not in blob.casefold() for token in required_tokens):
+        raise ValueError("Main timing proof lacks source/build/profile/boundary fields")
+    return {
+        "path": "native86-main166-timing-proof.json",
+        "sha256": sha256(path),
+        "schema": proof.get("schema"),
+        "status": proof.get("status"),
+        "binary_sha256": MAIN_BINARY,
+    }
+
+
+def main_row(
+    source: dict[str, Any], terminal: dict[str, Any], runtime: str,
+    timing_proof: dict[str, Any] | None,
+) -> dict[str, Any]:
+    if source.get("receipt_sha256") != terminal.get("receipt_sha256"):
+        raise ValueError("Dataset row receipt does not match terminal row")
+    if source.get("result_sha256") != terminal.get("result_sha256"):
+        raise ValueError("Dataset row result does not match terminal row")
+    if source.get("cold_sha256") != terminal.get("cold_sha256"):
+        raise ValueError("Dataset row cold result does not match terminal row")
+    if source.get("binary_sha256") != MAIN_BINARY:
+        raise ValueError("Unexpected server-166 main binary")
+    original = int(source["original_size_bytes"])
+    compressed = int(source["compressed_size_bytes"])
+    if original <= 0 or compressed <= 0:
+        raise ValueError("Main dataset result contains non-positive bytes")
+    rate = finite(source["compression_rate"], positive=True)
+    if not math.isclose(rate, compressed / original, rel_tol=2e-12, abs_tol=0.0):
+        raise ValueError("Main dataset result compression-rate mismatch")
+    timing_admitted = timing_proof is not None
+    evidence = str(source["evidence_tier"])
+    return {
+        "dataset": str(source["dataset"]),
+        "scope": str(source["scope"]),
+        "runtime": runtime,
+        "comparison_profile": runtime,
+        "method": str(source["method"]),
+        "family": str(source["family"]),
+        "algorithm_variant": str(source["algorithm_variant"]),
+        "is_best_rate_in_family": bool(source.get("is_best_rate_in_family", True)),
+        "original_size_bytes": original,
+        "compressed_size_bytes": compressed,
+        "point_count": int(source["point_count"]),
+        "compression_rate": rate,
+        "compression_time_ns": finite(source["compression_time_ns"]) if timing_admitted else None,
+        "decompression_time_ns": finite(source["decompression_time_ns"]) if timing_admitted else None,
+        "compression_time_ns_per_point": finite(source["compression_time_ns_per_point"]) if timing_admitted else None,
+        "decompression_time_ns_per_point": finite(source["decompression_time_ns_per_point"]) if timing_admitted else None,
+        "timing_column_count": int(source["timing_column_count"]) if timing_admitted else 0,
+        "timing_aggregation": str(source["timing_aggregation"]) if timing_admitted else "unavailable",
+        "eligible_dtype_scope": str(source["eligible_dtype_scope"]),
+        "eligible_column_set_sha256": str(source["eligible_aggregate_ids_sha256"]),
+        "eligible_column_set_status": "exact_sorted_aggregate_ids_sha256",
+        "measurement_status": f"rate_admitted_{evidence}_result_cold_sha_bound",
+        "timing_profile_status": (
+            "timing_admitted_frozen_source_build_binary_boundary_bound"
+            if timing_admitted else "timing_diagnostic_source_build_boundary_unbound"
+        ),
+        "binary_sha256": MAIN_BINARY,
+        "profile_version": source.get("profile_version"),
+        "receipt_path": source.get("receipt_path"),
+        "receipt_sha256": source.get("receipt_sha256"),
+        "result_sha256": source.get("result_sha256"),
+        "cold_sha256": source.get("cold_sha256"),
+        "done_sha256": source.get("done_sha256"),
+        "evidence_tier": evidence,
+    }
+
+
+def validate_pair_results(
+    results: list[dict[str, Any]], cold: list[dict[str, Any]],
+    dataset: str, method: str,
+) -> None:
+    if len(results) != len(cold) or not results:
+        raise ValueError(f"Result/cold row-count mismatch for {dataset}/{method}")
+    cold_by_id = {str(row["aggregate_id"]): row for row in cold}
+    if len(cold_by_id) != len(cold):
+        raise ValueError(f"Duplicate cold aggregate id for {dataset}/{method}")
+    for row in results:
+        aggregate_id = str(row["aggregate_id"])
+        verification = cold_by_id.get(aggregate_id)
+        if row.get("status") != "ok" or verification is None or verification.get("status") != "ok":
+            raise ValueError(f"Non-ok or missing verification for {aggregate_id}")
+        if row.get("dataset_id") != dataset or row.get("method") != method:
+            raise ValueError(f"Result identity mismatch for {aggregate_id}")
+        if verification.get("dataset_id") != dataset or verification.get("method") != method:
+            raise ValueError(f"Cold identity mismatch for {aggregate_id}")
+        if verification.get("complete_frame_sha256") != row.get("complete_frame_sha256"):
+            raise ValueError(f"Cold frame mismatch for {aggregate_id}")
+        original = finite(row["original_numeric_bytes"], positive=True)
+        compressed = finite(row["complete_frame_bytes"], positive=True)
+        if not math.isclose(finite(row["compression_ratio"], positive=True), compressed / original, rel_tol=2e-12):
+            raise ValueError(f"Rate mismatch for {aggregate_id}")
+
+
+def rows_for_verified_pair(
+    results: list[dict[str, Any]], *, runtime: str, binary_sha: str,
+    comparison_profile: str, measurement_status: str, timing_status: str,
+    timing_admitted: bool, provenance: dict[str, Any], allow_overall: bool = True,
+) -> list[dict[str, Any]]:
+    first = results[0]
+    dataset, family = str(first["dataset_id"]), str(first["method"])
+    method = str(first["configuration"])
+    groups: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in results:
+        if row.get("configuration") != method:
+            raise ValueError(f"Multiple configurations in one pair: {dataset}/{family}")
+        groups[dtype_scope(str(row["dtype"]))].append(row)
+        if allow_overall:
+            groups["overall"].append(row)
+    output: list[dict[str, Any]] = []
+    for scope, source in sorted(groups.items()):
+        original = sum(int(row["original_numeric_bytes"]) for row in source)
+        compressed = sum(int(row["complete_frame_bytes"]) for row in source)
+        point_count = sum(int(row["row_count"]) for row in source)
+        output.append({
+            "dataset": dataset,
+            "scope": scope,
+            "runtime": runtime,
+            "comparison_profile": comparison_profile,
+            "method": method,
+            "family": family,
+            # Exact binaries remain distinct implementations inside a shared
+            # host/campaign comparison profile.  This prevents two adapter
+            # builds of one algorithm from being silently pooled.
+            "algorithm_variant": f"{method} [{binary_sha[:8]}]",
+            "is_best_rate_in_family": True,
+            "original_size_bytes": original,
+            "compressed_size_bytes": compressed,
+            "point_count": point_count,
+            "compression_rate": compressed / original,
+            "compression_time_ns": sum(finite(row["compression_ns"]) for row in source) if timing_admitted else None,
+            "decompression_time_ns": sum(finite(row["decompression_ns"]) for row in source) if timing_admitted else None,
+            "compression_time_ns_per_point": (
+                sum(finite(row["compression_ns_per_logical_point"]) for row in source) / len(source)
+                if timing_admitted else None
+            ),
+            "decompression_time_ns_per_point": (
+                sum(finite(row["decompression_ns_per_logical_point"]) for row in source) / len(source)
+                if timing_admitted else None
+            ),
+            "timing_column_count": len(source) if timing_admitted else 0,
+            "timing_aggregation": "column_mean" if timing_admitted else "unavailable",
+            "eligible_dtype_scope": scope,
+            "eligible_column_set_sha256": canonical_sha(str(row["aggregate_id"]) for row in source),
+            "eligible_column_set_status": "exact_sorted_aggregate_ids_sha256",
+            "measurement_status": measurement_status,
+            "timing_profile_status": timing_status,
+            "binary_sha256": binary_sha,
+            "profile_version": first.get("profile_version"),
+            **provenance,
+        })
+    return output
+
+
+def recompute(data: dict[str, Any]) -> None:
+    rows = data["dataset_results"]
+    configurations: dict[tuple[str, str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    family_candidate_groups: dict[tuple[str, str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        if row.get("point_count") is None:
+            row["point_count"] = row["original_size_bytes"] / 8.0
+        profile = str(row.get("comparison_profile", row["runtime"]))
+        configurations[profile, row["scope"], row["family"], row["algorithm_variant"]].append(row)
+        key = profile, row["scope"], row["dataset"], row["family"]
+        family_candidate_groups[key].append(row)
+    family_candidates: list[dict[str, Any]] = []
+    ambiguous_support_groups = 0
+    for candidates in family_candidate_groups.values():
+        if len({str(row["eligible_column_set_sha256"]) for row in candidates}) != 1:
+            ambiguous_support_groups += 1
+            continue
+        family_candidates.append(min(candidates, key=lambda row: (row["compression_rate"], row["method"])))
+    families: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in family_candidates:
+        profile = str(row.get("comparison_profile", row["runtime"]))
+        families[profile, row["scope"], row["family"]].append(row)
+    data["configuration_aggregates"] = [
+        _aggregate_rows(source, runtime=runtime, scope_key=scope, family=family,
+                        method=method, algorithm_variant=method)
+        for (runtime, scope, family, method), source in sorted(configurations.items())
+    ]
+    data["family_best_aggregates"] = [
+        _aggregate_rows(source, runtime=runtime, scope_key=scope, family=family,
+                        method=family, algorithm_variant=None)
+        for (runtime, scope, family), source in sorted(families.items())
+    ]
+    data["family_best_support_contract"] = {
+        "status": "passed",
+        "selection": "one support hash per comparison-profile/scope/dataset/family before lowest-rate selection",
+        "omitted_ambiguous_dataset_family_groups": ambiguous_support_groups,
+    }
+
+
+def load_host192(profile_roots: list[Path]) -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, Any]]:
+    pairs = profile_pairs(profile_roots, HOST192)
+    if len(pairs) != 21 or sum(int(pair["expected_rows"]) for pair in pairs) != 1751:
+        raise ValueError("Expected the independently verified 21-pair/1,751-aggregate host192 cohort")
+    rows: list[dict[str, Any]] = []
+    admitted: list[dict[str, Any]] = []
+    profile_counts: Counter[str] = Counter()
+    for pair in pairs:
+        entry_path = pair["results_path"].parent / "PROFILE_ENTRY.json"
+        entry = read_json(entry_path)
+        verifier = read_json(pair["verification_path"])
+        binary_sha = str(entry.get("binary_sha256") or verifier.get("binary_sha256"))
+        if len(binary_sha) != 64:
+            raise ValueError(f"Host192 profile lacks a bound binary SHA-256: {entry_path}")
+        campaign = str(entry.get("campaign_id") or entry_path.parent.name)
+        if campaign.startswith("next5"):
+            campaign_key = "next5"
+        elif campaign.startswith("first12"):
+            campaign_key = "first12"
+        elif campaign.startswith("lzg"):
+            campaign_key = "lzg-level5-fastfalse"
+        else:
+            raise ValueError(f"Unexpected host192 campaign: {campaign}")
+        runtime = runtime_key("192", campaign_key, binary_sha)
+        results, cold = read_jsonl(pair["results_path"]), read_jsonl(pair["cold_path"])
+        if len(results) != int(pair["expected_rows"]):
+            raise ValueError("Host192 expected aggregate count changed")
+        validate_pair_results(results, cold, pair["dataset"], pair["method"])
+        rows.extend(rows_for_verified_pair(
+            results,
+            runtime=runtime,
+            binary_sha=binary_sha,
+            comparison_profile=f"cpp-native192-{campaign_key}-{first_profile_version(results)}",
+            measurement_status="independent_pair_verification_result_cold_sha_bound",
+            timing_status="timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof",
+            timing_admitted=False,
+            provenance={
+                "verification_sha256": pair["verification_sha256"],
+                "result_sha256": sha256(pair["results_path"]),
+                "cold_sha256": sha256(pair["cold_path"]),
+                "source_kind": pair["source_kind"],
+            },
+        ))
+        profile_counts[runtime] += 1
+        admitted.append({
+            "dataset": pair["dataset"], "method": pair["method"], "runtime": runtime,
+            "binary_sha256": binary_sha, "aggregate_count": len(results),
+            "result_sha256": sha256(pair["results_path"]), "cold_sha256": sha256(pair["cold_path"]),
+            "verification_sha256": pair["verification_sha256"],
+        })
+    if len({(item["dataset"], item["method"]) for item in admitted}) != 21:
+        raise ValueError("Host192 contains duplicate identities")
+    return rows, admitted, dict(sorted(profile_counts.items()))
+
+
+def load_v9(
+    thin_path: Path, reconciliation: dict[str, Any], main_terminal: dict[tuple[str, str], dict[str, Any]],
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]], dict[str, Any]]:
+    source_binding = reconciliation.get("source_artifacts", {}).get("v9_current154_thin", {})
+    require_hash(thin_path, str(source_binding.get("sha256")), "current V9 thin export")
+    records = read_gzip_jsonl(thin_path)
+    header = [row for row in records if row.get("record_type") == "export_header"]
+    terminals = [row for row in records if row.get("record_type") == "terminal_pair"]
+    aggregates = [row for row in records if row.get("record_type") == "aggregate_result"]
+    if (
+        len(header) != 1
+        or header[0].get("schema") != "paper164-v9-current154-thin-export-v1"
+        or header[0].get("source_host") != HOST166
+        or int(header[0].get("pair_count", -1)) != 154
+        or len(terminals) != 154
+        or len(aggregates) != 5604
+    ):
+        raise ValueError("Current V9 thin export shape/schema changed")
+    terminal_by_identity = {(str(row["dataset_id"]), str(row["method"])): row for row in terminals}
+    if len(terminal_by_identity) != 154:
+        raise ValueError("Current V9 thin export contains duplicate pair identities")
+    aggregate_by_identity: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in aggregates:
+        aggregate_by_identity[str(row["dataset_id"]), str(row["method"])].append(row)
+    rows: list[dict[str, Any]] = []
+    admitted: list[dict[str, Any]] = []
+    profile_counts: Counter[str] = Counter()
+    for (dataset, method), terminal_item in sorted(terminal_by_identity.items()):
+        original = main_terminal.get((dataset, method))
+        if original is None or original.get("receipt_status") not in {"failed", "complete_with_failures"}:
+            raise ValueError(f"V9 repair does not replace a failed main identity: {dataset}/{method}")
+        if (
+            terminal_item.get("schema") != "paper164-v9-current154-terminal-pair-v1"
+            or terminal_item.get("receipt_status") != "recovered"
+            or terminal_item.get("fresh_cold_process") is not True
+            or terminal_item.get("rate_and_bytes_admission") != "receipt_result_cold_sha_bound"
+            or terminal_item.get("timing_admission") != "diagnostic_per_variant_until_independent_source_build_boundary_proof"
+        ):
+            raise ValueError(f"V9 terminal is not rate/bytes admitted with diagnostic timing: {dataset}/{method}")
+        binary_sha = str(terminal_item["binary_sha256"])
+        if len(binary_sha) != 64:
+            raise ValueError(f"V9 terminal has no binary SHA-256: {dataset}/{method}")
+        runtime = runtime_key("166", "recovery", binary_sha)
+        all_results = aggregate_by_identity.get((dataset, method), [])
+        if len(all_results) != int(terminal_item["result_rows"]):
+            raise ValueError(f"V9 aggregate count does not match terminal: {dataset}/{method}")
+        results = [row for row in all_results if row.get("status") == "ok"]
+        if len(results) != int(terminal_item["numeric_ok_aggregate_count"]) or not results:
+            raise ValueError(f"V9 numeric aggregate count changed: {dataset}/{method}")
+        if canonical_sha(str(row["aggregate_id"]) for row in results) != terminal_item["numeric_ok_aggregate_ids_sha256"]:
+            raise ValueError(f"V9 numeric support hash changed: {dataset}/{method}")
+        for row in results:
+            if (
+                row.get("schema") != "paper164-v9-current154-aggregate-result-v1"
+                or row.get("cold_status") != "ok"
+                or row.get("cold_fresh_process") is not True
+                or row.get("pair_receipt_sha256") != terminal_item.get("receipt_sha256")
+                or row.get("result_file_sha256") != terminal_item.get("result_sha256")
+                or row.get("cold_file_sha256") != terminal_item.get("cold_sha256")
+                or row.get("binary_sha256") != binary_sha
+                or row.get("complete_frame_sha256") != row.get("cold_complete_frame_sha256")
+            ):
+                raise ValueError(f"V9 aggregate evidence binding failed: {row.get('aggregate_id')}")
+            original_bytes = finite(row["original_numeric_bytes"], positive=True)
+            compressed_bytes = finite(row["complete_frame_bytes"], positive=True)
+            if not math.isclose(finite(row["compression_ratio"], positive=True), compressed_bytes / original_bytes, rel_tol=2e-12):
+                raise ValueError(f"V9 aggregate rate mismatch: {row.get('aggregate_id')}")
+        has_na = int(terminal_item.get("result_status_counts", {}).get("N/A", 0)) > 0
+        rows.extend(rows_for_verified_pair(
+            results,
+            runtime=runtime,
+            binary_sha=binary_sha,
+            comparison_profile="cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3",
+            measurement_status="v9_recovery_receipt_result_cold_sha_bound",
+            timing_status="timing_diagnostic_recovery_campaign_binary_receipt_bound",
+            timing_admitted=False,
+            provenance={
+                "receipt_path": str(terminal_item["receipt_path"]),
+                "receipt_sha256": str(terminal_item["receipt_sha256"]),
+                "result_sha256": str(terminal_item["result_sha256"]),
+                "cold_sha256": str(terminal_item["cold_sha256"]),
+                "source_kind": "v9_current154_thin_export",
+                "original_receipt_status": str(original["receipt_status"]),
+                "variant_id": str(terminal_item["variant_id"]),
+            },
+            allow_overall=not has_na,
+        ))
+        profile_counts[runtime] += 1
+        admitted.append({
+            "dataset": dataset, "method": method, "runtime": runtime,
+            "binary_sha256": binary_sha, "aggregate_count": len(results),
+            "receipt_sha256": str(terminal_item["receipt_sha256"]),
+            "result_sha256": str(terminal_item["result_sha256"]),
+            "cold_sha256": str(terminal_item["cold_sha256"]),
+            "original_receipt_status": str(original["receipt_status"]),
+            "variant_id": str(terminal_item["variant_id"]),
+        })
+    if len(admitted) != 154 or sum(item["aggregate_count"] for item in admitted) != 5296:
+        raise ValueError("V9 admitted pair/numeric aggregate totals changed")
+    return rows, admitted, dict(sorted(profile_counts.items()))
+
+
+def build(args: argparse.Namespace) -> dict[str, Any]:
+    root = args.data.resolve().parent
+    data = read_json(args.data)
+    allowed = {str(item["key"]) for item in data["datasets"]}
+    if len(allowed) != 164:
+        raise ValueError("Website dataset scope must contain exactly 164 datasets")
+
+    export_manifest = read_json(args.main_manifest)
+    if export_manifest.get("status") != "passed" or export_manifest.get("source_host") != HOST166:
+        raise ValueError("Full main166 export manifest is not passed/host-bound")
+    files = export_manifest["files"]
+    for key, path in (("terminal_pair", args.main_terminal), ("dataset_result", args.main_dataset_results)):
+        require_hash(path, str(files[key]["compressed_sha256"]), f"main {key}")
+
+    terminal_rows = read_gzip_jsonl(args.main_terminal)
+    if len(terminal_rows) != 13940:
+        raise ValueError("Main terminal matrix must contain 13,940 rows")
+    terminal = {(str(row["dataset_id"]), str(row["method_label"])): row for row in terminal_rows}
+    if len(terminal) != 13940 or {row["dataset_id"] for row in terminal_rows} != allowed:
+        raise ValueError("Main terminal matrix identity/dataset coverage changed")
+    if any(str(row["method_label"]).casefold() == "glza" for row in terminal_rows):
+        raise ValueError("GLZA must be absent from the website164 terminal matrix")
+    shape_counts = Counter(str(row["pair_shape"]) for row in terminal_rows)
+    if dict(shape_counts) != EXPECTED_MAIN_SHAPES:
+        raise ValueError(f"Main pair-shape counts changed: {shape_counts}")
+
+    timing_proof = verify_main_timing_proof(args.main_timing_proof)
+    main_runtime = runtime_key("166", "main", MAIN_BINARY)
+    main_rows: list[dict[str, Any]] = []
+    dropped_mixed_overall = 0
+    for source in read_gzip_jsonl(args.main_dataset_results):
+        identity = str(source["dataset"]), str(source["family"])
+        pair = terminal.get(identity)
+        if pair is None or pair.get("receipt_status") != "ok":
+            raise ValueError(f"Numeric main row lacks receipt-ok terminal: {identity}")
+        if source.get("scope") == "overall" and pair.get("pair_shape") == "mixed_numeric_ok_and_na":
+            dropped_mixed_overall += 1
+            continue
+        if source.get("scope") == "overall" and pair.get("pair_shape") != "all_numeric_ok":
+            raise ValueError(f"Overall row exists for a non-complete support pair: {identity}")
+        main_rows.append(main_row(source, pair, main_runtime, timing_proof))
+    if dropped_mixed_overall != 1708 or len(main_rows) != 25443:
+        raise ValueError("Main support-aware dataset-row counts changed")
+    numeric_main_pairs = {(row["dataset"], row["family"]) for row in main_rows}
+    if len(numeric_main_pairs) != 11164:
+        raise ValueError("Main numeric pair count must be 11,164")
+
+    reconciliation = read_json(args.recovery_reconciliation)
+    expected_recovery_counts = {
+        "original_active_problem_pairs": 502,
+        "v9_current_recovered_pairs": 154,
+        "host192_strict_pairs": 21,
+        "v9_host192_overlap_pairs": 1,
+        "accepted_unique_repair_pairs": 174,
+        "current_unresolved_pairs": 328,
+        "omitted_unresolved_pairs": 1,
+    }
+    if (
+        reconciliation.get("schema") != "paper164-recovery-key-reconciliation-v1"
+        or reconciliation.get("status") != "passed_with_one_omitted_problem_scheduled_for_separate_sidecar"
+        or any(int(reconciliation.get("counts", {}).get(key, -1)) != value for key, value in expected_recovery_counts.items())
+    ):
+        raise ValueError("Recovery reconciliation status/counts changed")
+    v9_rows, v9_pairs, v9_profiles = load_v9(args.v9_thin, reconciliation, terminal)
+    host192_rows, host192_pairs, host192_profiles = load_host192(args.profile_root)
+    problem_identities = {
+        identity for identity, row in terminal.items()
+        if row.get("receipt_status") in {"failed", "complete_with_failures"}
+    }
+    v9_identities = {(row["dataset"], row["method"]) for row in v9_pairs}
+    host192_identities = {(row["dataset"], row["method"]) for row in host192_pairs}
+    if not (v9_identities | host192_identities) <= problem_identities:
+        raise ValueError("Accepted repair identity is not one of the 502 main problems")
+    overlap = v9_identities & host192_identities
+    repaired_identities = v9_identities | host192_identities
+    accepted_from_receipt = {
+        (str(row["dataset_id"]), str(row["method"]))
+        for row in reconciliation["accepted_pair_identities"]
+    }
+    if len(v9_identities) != 154 or len(host192_identities) != 21 or overlap != {("weather_data_bavaria", "LZG")}:
+        raise ValueError("V9/host192 accepted-repair sets changed")
+    if repaired_identities != accepted_from_receipt or len(repaired_identities) != 174:
+        raise ValueError("Accepted repair union does not match the reconciliation receipt")
+
+    legacy = [
+        row for row in data["dataset_results"]
+        if not str(row.get("runtime", "")).startswith("cpp-native")
+        and str(row.get("family", "")).casefold() != "glza"
+        and "glza" not in str(row.get("method", "")).casefold()
+    ]
+    dbp_timing = verify_legacy_dbp_timing(args.legacy_dbp_receipt, args.legacy_dbp_independent_review)
+    annotate_legacy(legacy, dbp_timing)
+    combined = legacy + main_rows + v9_rows + host192_rows
+    if any(str(row.get("family", "")).casefold() == "glza" or "glza" in str(row.get("method", "")).casefold() for row in combined):
+        raise ValueError("GLZA leaked into published numeric rows")
+    data["dataset_results"] = sorted(
+        combined, key=lambda row: (
+            row["dataset"], row["scope"], row.get("comparison_profile", row["runtime"]),
+            row["runtime"], row["family"], row["algorithm_variant"],
+        )
+    )
+    recompute(data)
+
+    source_profiles = sorted({str(row["runtime"]) for row in combined})
+    runtimes = sorted({str(row.get("comparison_profile", row["runtime"])) for row in combined})
+    labels = {"cpp": "C++", "java": "Java", "python": "Python"}
+    hosts = {"cpp": "source snapshot", "java": "source snapshot", "python": "source snapshot"}
+    for runtime in runtimes:
+        if runtime.startswith("cpp-native166-main"):
+            labels[runtime] = f"Native C++ · server 166 · main · {MAIN_BINARY[:8]}"
+            hosts[runtime] = "166"
+        elif runtime.startswith("cpp-native166-v9-recovery"):
+            labels[runtime] = "Native C++ · server 166 · V9 recovery · baseline86 v3"
+            hosts[runtime] = "166"
+        elif runtime.startswith("cpp-native192"):
+            parts = runtime.split("-")
+            campaign = " ".join(parts[2:4])
+            labels[runtime] = f"Native C++ · server 192 · {campaign}"
+            hosts[runtime] = "192"
+    data["benchmark"]["implementation_runtimes"] = runtimes
+    data["benchmark"]["exact_source_profiles"] = source_profiles
+    data["benchmark"]["runtime_labels"] = labels
+    data["benchmark"]["runtime_hosts"] = hosts
+    data["benchmark"]["publication_note"] = (
+        "The server-166 Native86 matrix covers all 13,940 website164×active-method terminal pairs: "
+        "11,164 main pairs contain at least one numeric aggregate, 2,274 are explicit N/A, and 502 "
+        "ended with problems. V9 supplies receipt-bound rate/byte replacements for 154 problem identities; "
+        "server 192 supplies 21 independently pair-verified replacements, with one overlapping identity, so "
+        "174 unique problem identities are repaired and 328 remain unresolved. Numeric rows require matching "
+        "result/cold hashes. The independent Native166 "
+        "adjudication covers 773 archived strict-admission pairs; other main rows retain their active/self/"
+        "archived evidence tier. Server-192's 21 pairs carry independent pair-verification receipts. "
+        "Host/campaign/measurement-contract comparison profiles remain separate; exact adapter and binary "
+        "identities remain distinct configurations inside those profiles. Legacy source-snapshot and "
+        "server-192 timings without exact source/build/binary/boundary proof are unavailable to timing and "
+        "composite rankings; the six receipt-bound DBP medium_posts rows retain admitted timing."
+    )
+    boundary = (
+        "Rank comparisons use matching eligible aggregate-id support hashes; mixed-support pairs have no overall row."
+    )
+    if boundary not in data["benchmark"].setdefault("measurement_boundaries", []):
+        data["benchmark"]["measurement_boundaries"].append(boundary)
+
+    # Replace stale native runtime memberships in the public method catalog.
+    method_map = {(str(item["name"]), str(item["family"])): item for item in data["methods"]}
+    for item in data["methods"]:
+        item["runtimes"] = [runtime for runtime in item.get("runtimes", []) if not str(runtime).startswith("cpp-native")]
+    family_examples = {str(item["family"]): item for item in data["methods"]}
+    for row in main_rows + v9_rows + host192_rows:
+        key = str(row["algorithm_variant"]), str(row["family"])
+        item = method_map.get(key)
+        if item is None:
+            example = family_examples.get(key[1], {})
+            item = {
+                "name": key[0], "family": key[1], "runtimes": [],
+                "operator_pipeline": example.get("operator_pipeline"),
+                "operator_pipeline_status": example.get("operator_pipeline_status", "not_available"),
+            }
+            data["methods"].append(item)
+            method_map[key] = item
+        comparison_profile = str(row.get("comparison_profile", row["runtime"]))
+        if comparison_profile not in item["runtimes"]:
+            item["runtimes"].append(comparison_profile)
+    data["methods"] = sorted(data["methods"], key=lambda item: (item["family"], item["name"]))
+
+    # Preserve non-native source runs and replace the incomplete v5 native run summaries.
+    measurement_runs = [
+        run for run in data["source"].get("measurement_runs", [])
+        if run.get("schema") != "site-native86-receipt-bound-import-v1"
+        and run.get("schema") != "site-native86-full-matrix-import-v2"
+    ]
+    profile_summary: dict[str, dict[str, Any]] = {}
+    for runtime in sorted(set([main_runtime, *v9_profiles, *host192_profiles])):
+        selected = [row for row in main_rows + v9_rows + host192_rows if row["runtime"] == runtime]
+        pairs = {(row["dataset"], row["family"]) for row in selected}
+        aggregate_count = sum(
+            item["aggregate_count"] for item in [*v9_pairs, *host192_pairs]
+            if item["runtime"] == runtime
+        ) if runtime != main_runtime else 290745
+        profile_summary[runtime] = {
+            "execution_host": HOST166 if runtime.startswith("cpp-native166") else HOST192,
+            "pair_count": len(pairs), "aggregate_count": aggregate_count,
+            "dataset_result_count": len(selected),
+            "binary_sha256": selected[0].get("binary_sha256"),
+            "timing_profile_status": selected[0].get("timing_profile_status"),
+            "comparison_profiles": sorted({str(row.get("comparison_profile", row["runtime"])) for row in selected}),
+        }
+    comparison_summary: dict[str, dict[str, Any]] = {}
+    for comparison_profile in sorted({str(row.get("comparison_profile", row["runtime"])) for row in main_rows + v9_rows + host192_rows}):
+        selected = [
+            row for row in main_rows + v9_rows + host192_rows
+            if str(row.get("comparison_profile", row["runtime"])) == comparison_profile
+        ]
+        comparison_summary[comparison_profile] = {
+            "execution_host": HOST166 if comparison_profile.startswith("cpp-native166") else HOST192,
+            "pair_count": len({(row["dataset"], row["family"], row["algorithm_variant"]) for row in selected}),
+            "dataset_result_count": len(selected),
+            "exact_source_profiles": sorted({str(row["runtime"]) for row in selected}),
+            "timing_admitted": all("diagnostic" not in str(row.get("timing_profile_status", "")) for row in selected),
+        }
+    measurement_runs.append({
+        "schema": "site-native86-full-matrix-import-v2",
+        "integrated_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "terminal_pair_count": 13940,
+        "main_numeric_pair_count": 11164,
+        "main_all_na_pair_count": 2274,
+        "main_problem_pair_count": 502,
+        "v9_recovered_pair_count": 154,
+        "accepted_unique_repair_pair_count": 174,
+        "accepted_repair_overlap_pair_count": 1,
+        "unresolved_problem_pair_count": 328,
+        "host192_independently_verified_pair_count": 21,
+        "profiles": profile_summary,
+        "comparison_profiles": comparison_summary,
+        "evidence_tier_counts": dict(export_manifest["summary"]["evidence_tier_counts"]),
+        "main_timing_proof": timing_proof,
+        "legacy_timing_policy": {
+            "diagnostic_rows_published_as_unavailable": sum(
+                row.get("timing_profile_status")
+                == "timing_diagnostic_source_snapshot_host_or_build_boundary_unbound_not_ranked"
+                for row in legacy
+            ),
+            "dbp_medium_posts_admitted_rows": sum(
+                row.get("timing_profile_status")
+                == "timing_admitted_dbp_medium_posts_source_build_binary_boundary_bound"
+                for row in legacy
+            ),
+            "dbp_medium_posts_receipt_sha256": DBP_MEDIUM_RECEIPT_SHA,
+            "dbp_medium_posts_independent_review_sha256": DBP_MEDIUM_INDEPENDENT_SHA,
+        },
+    })
+    data["source"]["measurement_runs"] = measurement_runs
+
+    coverage = data["coverage"]
+    for stale_key in (
+        "native86_verified_pair_count", "native86_verified_aggregate_count", "native86_verified_by_runtime",
+    ):
+        coverage.pop(stale_key, None)
+    coverage.update(
+        dataset_count=164,
+        catalog_dataset_count=164,
+        measured_dataset_count=len({row["dataset"] for row in combined}),
+        runtime_count=len(runtimes),
+        runtimes=runtimes,
+        dataset_result_row_count=len(combined),
+        configuration_aggregate_row_count=len(data["configuration_aggregates"]),
+        family_best_aggregate_row_count=len(data["family_best_aggregates"]),
+        method_family_count=len({row["family"] for row in combined}),
+        method_configuration_count=len({row["algorithm_variant"] for row in combined}),
+        runtime_configuration_count=len({
+            (row.get("comparison_profile", row["runtime"]), row["algorithm_variant"]) for row in combined
+        }),
+        timing_column_observation_count=sum(int(row.get("timing_column_count", 0)) for row in combined),
+        timing_column_mean_dataset_result_count=sum(row.get("timing_aggregation") == "column_mean" for row in combined),
+        timing_dataset_aggregate_result_count=sum(row.get("timing_aggregation") == "dataset_aggregate" for row in combined),
+        timing_unavailable_dataset_result_count=sum(row.get("timing_aggregation") == "unavailable" for row in combined),
+        native86_terminal_pair_count=13940,
+        native86_main_numeric_pair_count=11164,
+        native86_main_all_na_pair_count=2274,
+        native86_main_problem_pair_count=502,
+        native86_v9_recovered_pair_count=154,
+        native86_accepted_unique_repair_pair_count=174,
+        native86_accepted_repair_overlap_pair_count=1,
+        native86_unresolved_problem_pair_count=328,
+        native86_host192_independently_verified_pair_count=21,
+        native86_profiles=profile_summary,
+        native86_comparison_profiles=comparison_summary,
+    )
+
+    args.data.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n", encoding="utf-8")
+
+    public_terminal = root / "native86-terminal-matrix.jsonl.gz"
+    public_main_dataset_results = root / "native86-main166-dataset-results.jsonl.gz"
+    public_v9_thin = root / "native86-v9-current154-thin.jsonl.gz"
+    public_reconciliation = root / "native86-recovery-reconciliation.json"
+    public_timing_proof = root / "native86-main166-timing-proof.json"
+    public_adjudication = root / "native86-main166-independent-adjudication.json"
+    public_pair_adjudication = root / "native86-main166-pair-adjudication.jsonl"
+    public_dbp_timing_receipt = root / "legacy-dbp-medium-posts-timing-receipt.json"
+    public_dbp_independent_review = root / "legacy-dbp-medium-posts-independent-review.json"
+    checkout = Path(__file__).resolve().parents[3]
+    shutil.copyfile(args.main_terminal, public_terminal)
+    shutil.copyfile(args.main_dataset_results, public_main_dataset_results)
+    shutil.copyfile(args.v9_thin, public_v9_thin)
+    public_reconciliation_value = sanitize_local_paths(reconciliation, Path(__file__).resolve().parents[3])
+    public_reconciliation_value["source_receipt_sha256"] = sha256(args.recovery_reconciliation)
+    public_reconciliation.write_text(
+        json.dumps(public_reconciliation_value, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    if args.main_timing_proof is None:
+        raise ValueError("A published v6 candidate requires the passed main166 timing proof")
+    shutil.copyfile(args.main_timing_proof, public_timing_proof)
+    for source, target in (
+        (args.legacy_dbp_receipt, public_dbp_timing_receipt),
+        (args.legacy_dbp_independent_review, public_dbp_independent_review),
+    ):
+        target.write_text(
+            json.dumps(sanitize_local_paths(read_json(source), checkout), ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+    adjudication = read_json(args.adjudication_receipt)
+    pair_binding = adjudication.get("pair_adjudication", {})
+    if (
+        adjudication.get("schema") != "paper164-native166-independent-adjudication-summary-v1"
+        or adjudication.get("status") != "partial_verification_blocked"
+        or adjudication.get("decision") != "do_not_claim_all_920_independently_verified"
+        or adjudication.get("status_counts") != {
+            "independently_adjudicated": 773,
+            "not_independently_adjudicated_missing_expected_gate_artifact": 147,
+        }
+    ):
+        raise ValueError("Native166 adjudication no longer preserves the partial decision")
+    require_hash(args.pair_adjudication, str(pair_binding.get("sha256")), "Native166 pair adjudication")
+    if sum(1 for line in args.pair_adjudication.open(encoding="utf-8") if line.strip()) != 920:
+        raise ValueError("Native166 pair adjudication row count changed")
+    with args.pair_adjudication.open(encoding="utf-8") as source, public_pair_adjudication.open("w", encoding="utf-8") as target:
+        for line in source:
+            if line.strip():
+                target.write(json.dumps(sanitize_local_paths(json.loads(line), checkout), ensure_ascii=False, sort_keys=True) + "\n")
+    public_adjudication_value = sanitize_local_paths(adjudication, checkout)
+    public_adjudication_value["source_receipt_sha256"] = sha256(args.adjudication_receipt)
+    public_adjudication_value["pair_adjudication"]["source_sha256"] = str(pair_binding["sha256"])
+    public_adjudication_value["pair_adjudication"]["path"] = public_pair_adjudication.name
+    public_adjudication_value["pair_adjudication"]["sha256"] = sha256(public_pair_adjudication)
+    public_adjudication.write_text(
+        json.dumps(public_adjudication_value, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    coverage_receipt = {
+        "schema": "site-native86-full-terminal-coverage-v2",
+        "status": "passed",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "dataset_count": 164,
+        "active_method_count": 85,
+        "terminal_pair_count": 13940,
+        "pair_shape_counts": EXPECTED_MAIN_SHAPES,
+        "main_numeric_pair_count": 11164,
+        "main_numeric_aggregate_count": 290745,
+        "main_dataset_result_count": 25443,
+        "dropped_mixed_overall_count": 1708,
+        "v9_recovered_pair_count": 154,
+        "v9_numeric_ok_aggregate_count": 5296,
+        "host192_independently_verified_pair_count": 21,
+        "accepted_unique_repair_pair_count": 174,
+        "accepted_repair_overlap_pair_count": 1,
+        "unresolved_problem_pair_count": 328,
+        "omitted_unresolved_pair_count": 1,
+        "files": {
+            public_terminal.name: {"sha256": sha256(public_terminal), "rows": 13940},
+            public_main_dataset_results.name: {
+                "sha256": sha256(public_main_dataset_results), "source_rows": 27151,
+                "published_support_aware_rows": 25443,
+            },
+            public_v9_thin.name: {
+                "sha256": sha256(public_v9_thin), "pairs": 154,
+                "numeric_ok_aggregates": 5296, "not_applicable_aggregates": 308,
+            },
+            public_reconciliation.name: {
+                "sha256": sha256(public_reconciliation), "status": reconciliation["status"],
+                "accepted_unique_repair_pairs": 174, "unresolved_problem_pairs": 328,
+            },
+            public_timing_proof.name: {"sha256": sha256(public_timing_proof), "status": "passed"},
+            public_dbp_timing_receipt.name: {
+                "sha256": sha256(public_dbp_timing_receipt),
+                "source_sha256": DBP_MEDIUM_RECEIPT_SHA,
+                "status": "passed",
+            },
+            public_dbp_independent_review.name: {
+                "sha256": sha256(public_dbp_independent_review),
+                "source_sha256": DBP_MEDIUM_INDEPENDENT_SHA,
+                "status": "passed",
+            },
+            public_adjudication.name: {
+                "sha256": sha256(public_adjudication), "status": "partial_verification_blocked",
+            },
+            public_pair_adjudication.name: {"sha256": sha256(public_pair_adjudication), "rows": 920},
+            args.main_dataset_results.name: {
+                "source_sha256": sha256(args.main_dataset_results), "source_rows": 27151,
+                "published_support_aware_rows": 25443,
+            },
+        },
+        "profiles": profile_summary,
+        "comparison_profiles": comparison_summary,
+        "main_timing_proof": timing_proof,
+        "legacy_dbp_medium_posts_timing": {
+            "receipt": {
+                "path": public_dbp_timing_receipt.name,
+                "sha256": sha256(public_dbp_timing_receipt),
+                "source_sha256": DBP_MEDIUM_RECEIPT_SHA,
+            },
+            "independent_review": {
+                "path": public_dbp_independent_review.name,
+                "sha256": sha256(public_dbp_independent_review),
+                "source_sha256": DBP_MEDIUM_INDEPENDENT_SHA,
+            },
+            "admitted_dataset_result_rows": 6,
+        },
+        "independent_adjudication": {
+            "path": public_adjudication.name,
+            "sha256": sha256(public_adjudication),
+            "pair_path": public_pair_adjudication.name,
+            "pair_sha256": sha256(public_pair_adjudication),
+            "status": "partial_verification_blocked",
+            "status_counts": adjudication["status_counts"],
+        },
+    }
+    coverage_path = root / "native86-coverage.json"
+    coverage_path.write_text(json.dumps(coverage_receipt, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    manifest = read_json(args.manifest)
+    manifest["data_sha256"] = sha256(args.data)
+    manifest["counts"] = coverage
+    manifest["native86_imports"] = profile_summary
+    manifest["native86_terminal_coverage"] = {
+        "path": public_terminal.name, "sha256": sha256(public_terminal), "rows": 13940,
+        "main_dataset_results": {
+            "path": public_main_dataset_results.name,
+            "sha256": sha256(public_main_dataset_results),
+            "source_rows": 27151,
+            "published_support_aware_rows": 25443,
+        },
+        "coverage_receipt": {"path": coverage_path.name, "sha256": sha256(coverage_path)},
+        "v9_current154": {"path": public_v9_thin.name, "sha256": sha256(public_v9_thin), "pairs": 154},
+        "recovery_reconciliation": {
+            "path": public_reconciliation.name,
+            "sha256": sha256(public_reconciliation),
+            "accepted_unique_repair_pairs": 174,
+            "unresolved_problem_pairs": 328,
+        },
+        "main_timing_proof": timing_proof,
+        "legacy_dbp_medium_posts_timing": coverage_receipt["legacy_dbp_medium_posts_timing"],
+        "independent_adjudication": coverage_receipt["independent_adjudication"],
+    }
+    args.manifest.write_text(json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n", encoding="utf-8")
+
+    receipt = {
+        "schema": "site-native86-full-matrix-integration-v2",
+        "status": "passed",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "data_sha256": sha256(args.data),
+        "manifest_sha256": sha256(args.manifest),
+        "coverage_sha256": sha256(coverage_path),
+        "terminal_matrix_sha256": sha256(public_terminal),
+        "v9_current154_sha256": sha256(public_v9_thin),
+        "recovery_reconciliation_sha256": sha256(public_reconciliation),
+        "counts": coverage_receipt,
+    }
+    args.receipt.write_text(json.dumps(receipt, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return receipt
+
+
+def parser() -> argparse.ArgumentParser:
+    root = Path(__file__).resolve().parent
+    repo = root.parents[2]
+    paper = repo / "analysis_outputs/paper164_performance_refresh_20261011"
+    bundle = repo / "analysis_outputs/site_native192_bundle_20261011"
+    value = argparse.ArgumentParser(description=__doc__)
+    value.add_argument("--data", type=Path, default=root / "data.json")
+    value.add_argument("--manifest", type=Path, default=root / "manifest.json")
+    value.add_argument("--main-manifest", type=Path, default=paper / "COVERAGE_SANITY.full_main166_export_manifest.json")
+    value.add_argument("--main-terminal", type=Path, default=paper / "COVERAGE_SANITY.full_main166_terminal_pairs.jsonl.gz")
+    value.add_argument("--main-dataset-results", type=Path, default=paper / "COVERAGE_SANITY.full_main166_dataset_results.jsonl.gz")
+    value.add_argument("--v9-thin", type=Path, default=paper / "COVERAGE_SANITY.v9_current154_thin.jsonl.gz")
+    value.add_argument(
+        "--recovery-reconciliation", type=Path,
+        default=paper / "COVERAGE_SANITY.recovery_key_reconciliation.json",
+    )
+    value.add_argument("--profile-root", type=Path, action="append", default=[])
+    value.add_argument("--main-timing-proof", type=Path)
+    value.add_argument(
+        "--legacy-dbp-receipt", type=Path,
+        default=repo / "analysis_outputs/column_mean_20261009/dbp_medium_posts_retest/measurement_receipt.json",
+    )
+    value.add_argument(
+        "--legacy-dbp-independent-review", type=Path,
+        default=repo / "analysis_outputs/dbp_medium_fallback_20261009/dbp_medium_independent_receipt.json",
+    )
+    value.add_argument(
+        "--adjudication-receipt", type=Path,
+        default=bundle / "independent_review/native166_adjudication/NATIVE166_ADJUDICATION_RECEIPT.json",
+    )
+    value.add_argument(
+        "--pair-adjudication", type=Path,
+        default=bundle / "independent_review/native166_adjudication/NATIVE166_PAIR_ADJUDICATION.jsonl",
+    )
+    value.add_argument("--receipt", type=Path, default=root / "NATIVE86_FULL_MATRIX_INTEGRATION_V6.json")
+    return value
+
+
+def main() -> int:
+    args = parser().parse_args()
+    if not args.profile_root:
+        repo = Path(__file__).resolve().parents[3]
+        args.profile_root = [
+            repo / "analysis_outputs/first12_sync_192_to166_20261010/payload/formal_native86",
+            repo / "analysis_outputs/lzg_sync_192_to166_20261010/payload/formal_native86",
+            repo / "analysis_outputs/site_native192_bundle_20261011/normalized_external_results/formal_native86",
+        ]
+    receipt = build(args)
+    print(json.dumps({"status": receipt["status"], "data_sha256": receipt["data_sha256"], "counts": receipt["counts"]}, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

integrate_native86_results.py

@@ -0,0 +1,643 @@
+#!/usr/bin/env python3
+"""Admit independently verified Native86 JSONL results into the site snapshot.
+
+The importer is deliberately receipt-bound.  It accepts either synced
+``PROFILE_ENTRY.json`` directories or a repaired next5 campaign.  Results and
+cold-decode rows must match by aggregate id and frame hash.  Execution hosts
+are represented by distinct runtime keys so timings from 166 and 192 are never
+pooled into one leaderboard cohort.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import math
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+
+from export_results import _aggregate_rows
+
+
+VERIFIED_PROFILE_STATUS = "externally_verified_complete"
+VERIFIED_PAIR_STATUS = "verified"
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def public_path(path: Path) -> str:
+    """Prefer checkout-relative provenance paths over workstation paths."""
+    resolved = path.resolve()
+    for base in (Path.cwd().resolve(), Path(__file__).resolve().parents[2]):
+        try:
+            return resolved.relative_to(base).as_posix()
+        except ValueError:
+            continue
+    return resolved.name
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError(f"Expected an object in {path}")
+    return value
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            try:
+                value = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSONL at {path}:{line_number}: {exc}") from exc
+            if not isinstance(value, dict):
+                raise ValueError(f"Expected an object at {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def finite(value: Any, *, positive: bool = False) -> float:
+    number = float(value)
+    if not math.isfinite(number) or (positive and number <= 0):
+        raise ValueError(f"Invalid numeric value: {value!r}")
+    return number
+
+
+def require_hash(path: Path, expected: str, label: str) -> None:
+    actual = sha256(path)
+    if actual != expected:
+        raise ValueError(f"{label} SHA-256 mismatch: expected {expected}, found {actual}")
+
+
+def profile_pairs(profile_roots: Iterable[Path], host: str) -> list[dict[str, Any]]:
+    pairs: list[dict[str, Any]] = []
+    for root in profile_roots:
+        for entry_path in sorted(root.rglob("PROFILE_ENTRY.json")):
+            entry = read_json(entry_path)
+            if entry.get("status") != VERIFIED_PROFILE_STATUS:
+                raise ValueError(f"Unverified profile entry: {entry_path}")
+            if entry.get("result_execution_host") != host or entry.get("timing_host_preserved") != host:
+                raise ValueError(f"Profile host mismatch: {entry_path}")
+            results_path = entry_path.parent / "results.jsonl"
+            cold_path = entry_path.parent / "cold.jsonl"
+            verification_path = entry_path.parent / "INDEPENDENT_VERIFICATION.source192.json"
+            files = entry.get("files", {})
+            require_hash(results_path, files["results.jsonl"]["sha256"], str(entry_path))
+            require_hash(cold_path, files["cold.jsonl"]["sha256"], str(entry_path))
+            verifier_record = files.get("INDEPENDENT_VERIFICATION.source192.json")
+            if not isinstance(verifier_record, dict):
+                raise ValueError(f"Profile lacks an independent verifier binding: {entry_path}")
+            require_hash(verification_path, verifier_record["sha256"], str(entry_path))
+            verifier = read_json(verification_path)
+            if verifier.get("status") != VERIFIED_PAIR_STATUS:
+                raise ValueError(f"Independent verifier is not verified: {verification_path}")
+            verifier_host = verifier.get("result_execution_host") or verifier.get("host")
+            accepted_hosts = {host}
+            if host == "192.168.99.20":
+                accepted_hosts.add("timecho-20")
+            if verifier_host not in accepted_hosts:
+                raise ValueError(f"Independent verifier host mismatch: {verification_path}")
+            expected_rows = int(entry["aggregate_count"])
+            if (
+                str(verifier.get("dataset_id")) != str(entry["dataset_id"])
+                or str(verifier.get("method")) != str(entry["method"])
+                or int(verifier.get("aggregate_count", -1)) != expected_rows
+            ):
+                raise ValueError(f"Independent verifier identity/count mismatch: {verification_path}")
+            for label, payload, path in (
+                ("results", verifier.get("results"), results_path),
+                ("cold", verifier.get("cold"), cold_path),
+            ):
+                if not isinstance(payload, dict):
+                    raise ValueError(f"Independent verifier lacks {label}: {verification_path}")
+                status_counts = payload.get("status_counts")
+                if int(payload.get("rows", -1)) != expected_rows or (
+                    status_counts is not None and status_counts != {"ok": expected_rows}
+                ):
+                    raise ValueError(f"Independent verifier {label} count/status mismatch: {verification_path}")
+                require_hash(path, str(payload.get("sha256")), f"independent verifier {label}")
+            pairs.append({
+                "dataset": str(entry["dataset_id"]),
+                "method": str(entry["method"]),
+                "results_path": results_path,
+                "cold_path": cold_path,
+                "verification_path": verification_path,
+                "verification_sha256": sha256(verification_path),
+                "expected_rows": expected_rows,
+                "source_kind": "synced_profile_entry",
+            })
+    return pairs
+
+
+def next5_pairs(root: Path, host: str) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    final_path = root / "repairs/appledouble_inventory_v1/FINAL_REPAIRED_INDEPENDENT_VERIFICATION.json"
+    final = read_json(final_path)
+    if final.get("status") != VERIFIED_PAIR_STATUS or final.get("result_execution_host") != host:
+        raise ValueError("The repaired next5 campaign lacks a verified host-bound final receipt")
+    if final.get("timing_hardware_comparability") != "host192_only_not_comparable_to166":
+        raise ValueError("The repaired next5 receipt lost its cross-host timing boundary")
+    pairs: list[dict[str, Any]] = []
+    for item in final.get("pairs", []):
+        key = str(item["selection_key_hex"])
+        pair_dir = root / "pairs" / key
+        verification_path = pair_dir / "INDEPENDENT_VERIFICATION.json"
+        if item.get("admission_source") == "replacement_reverification":
+            verification_path = root / "repairs/appledouble_inventory_v1/pairs" / key / "INDEPENDENT_VERIFICATION.json"
+        verification = read_json(verification_path)
+        if verification.get("status") != VERIFIED_PAIR_STATUS:
+            raise ValueError(f"Unverified next5 pair: {verification_path}")
+        if verification.get("result_execution_host") != host:
+            raise ValueError(f"Next5 host mismatch: {verification_path}")
+        results_path = pair_dir / "results.jsonl"
+        cold_path = pair_dir / "cold.jsonl"
+        require_hash(results_path, str(item["results_sha256"]), str(final_path))
+        require_hash(cold_path, str(item["cold_sha256"]), str(final_path))
+        require_hash(verification_path, str(item["verification_sha256"]), str(final_path))
+        pairs.append({
+            "dataset": str(item["dataset_id"]),
+            "method": str(item["method"]),
+            "results_path": results_path,
+            "cold_path": cold_path,
+            "verification_path": verification_path,
+            "verification_sha256": sha256(verification_path),
+            "expected_rows": int(item["aggregate_count"]),
+            "source_kind": str(item["admission_source"]),
+        })
+    if len(pairs) != 5 or sum(pair["expected_rows"] for pair in pairs) != 280:
+        raise ValueError("The repaired next5 final receipt must bind 5 pairs and 280 aggregates")
+    return pairs, {"path": public_path(final_path), "sha256": sha256(final_path), "schema": final.get("schema")}
+
+
+def inventory_pairs(inventory_path: Path, payload_root: Path, host: str) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    inventory = read_json(inventory_path)
+    if inventory.get("status") != "verified_exact_results_cold_only" or inventory.get("execution_host") != host:
+        raise ValueError("Native source inventory is not verified for the selected host")
+    pairs: list[dict[str, Any]] = []
+    for item in inventory.get("pairs", []):
+        def local(source: str) -> Path:
+            return payload_root / source.lstrip("/")
+        receipt_path = local(str(item["receipt_path"]))
+        require_hash(receipt_path, str(item["receipt_sha256"]), "native inventory receipt")
+        receipt = read_json(receipt_path)
+        if receipt.get("status") not in {"ok", "recovered"}:
+            raise ValueError(f"Native inventory receipt lost terminal status: {receipt_path}")
+        admission = item.get("admission_path")
+        verification_path = receipt_path
+        if admission:
+            verification_path = local(str(admission))
+            require_hash(verification_path, str(item["admission_sha256"]), "strict admission")
+            if read_json(verification_path).get("status") != "admitted_after_strict_revalidation":
+                raise ValueError(f"Strict admission lost status: {verification_path}")
+        results_path = local(str(item["result_path"]))
+        cold_path = local(str(item["cold_path"]))
+        require_hash(results_path, str(receipt["result_sha256"]), "native result")
+        require_hash(cold_path, str(receipt["cold_sha256"]), "native cold result")
+        pairs.append({
+            "dataset": str(item["dataset"]), "method": str(item["method"]),
+            "results_path": results_path, "cold_path": cold_path,
+            "verification_path": verification_path,
+            "verification_sha256": sha256(verification_path),
+            "expected_rows": int(item["rows"]), "source_kind": str(item["kind"]),
+        })
+    if len(pairs) != int(inventory.get("pair_count", -1)) or sum(p["expected_rows"] for p in pairs) != int(inventory.get("aggregate_count", -1)):
+        raise ValueError("Native source inventory totals do not match its pairs")
+    return pairs, {"path": public_path(inventory_path), "sha256": sha256(inventory_path), "schema": inventory.get("schema"), "status": inventory.get("status")}
+
+
+def adjudication_receipt(path: Path, pairs: list[dict[str, Any]], host: str) -> dict[str, Any]:
+    receipt = read_json(path)
+    if (
+        receipt.get("schema") != "paper164-native166-independent-adjudication-summary-v1"
+        or receipt.get("status") != "partial_verification_blocked"
+        or receipt.get("execution_host") != host
+        or receipt.get("decision") != "do_not_claim_all_920_independently_verified"
+    ):
+        raise ValueError("Native166 adjudication does not preserve its partial/blocked decision")
+    detail = path.parent / "NATIVE166_PAIR_ADJUDICATION.jsonl"
+    binding = receipt.get("pair_adjudication", {})
+    require_hash(detail, str(binding.get("sha256")), "Native166 pair adjudication")
+    rows = read_jsonl(detail)
+    if len(rows) != int(binding.get("rows", -1)) or len(rows) != len(pairs):
+        raise ValueError("Native166 adjudication row count does not match imported pairs")
+    expected = {(pair["dataset"], pair["method"], pair["expected_rows"]) for pair in pairs}
+    observed = {(str(row["dataset_id"]), str(row["method"]), int(row["aggregate_count"])) for row in rows}
+    if expected != observed:
+        raise ValueError("Native166 adjudication identities/counts do not match imported pairs")
+    statuses = Counter(str(row.get("status")) for row in rows)
+    expected_statuses = {
+        "independently_adjudicated": 773,
+        "not_independently_adjudicated_missing_expected_gate_artifact": 147,
+    }
+    if dict(statuses) != expected_statuses or receipt.get("status_counts") != expected_statuses:
+        raise ValueError("Native166 adjudication status counts changed")
+    if int(receipt.get("pair_count", -1)) != len(pairs) or int(receipt.get("aggregate_count", -1)) != sum(p["expected_rows"] for p in pairs):
+        raise ValueError("Native166 adjudication totals do not match imported pairs")
+    return {
+        "path": public_path(path), "sha256": sha256(path), "schema": receipt.get("schema"),
+        "status": receipt.get("status"), "decision": receipt.get("decision"),
+        "status_counts": expected_statuses,
+        "pair_adjudication_sha256": sha256(detail),
+    }
+
+
+def campaign_receipt(path: Path, pairs: list[dict[str, Any]], host: str) -> dict[str, Any]:
+    receipt = read_json(path)
+    status = str(receipt.get("status", ""))
+    if status not in {"verified_all12", "verified_all_four_requested_remaining_datasets"}:
+        raise ValueError(f"Campaign receipt is not a supported verified completion: {path}")
+    if receipt.get("result_execution_host") not in {None, host}:
+        raise ValueError(f"Campaign receipt host mismatch: {path}")
+    by_identity = {(pair["dataset"], pair["method"]): pair for pair in pairs}
+    claimed: list[tuple[str, str, int, str, str]] = []
+    if status == "verified_all12":
+        for item in receipt.get("pairs", []):
+            claimed.append((
+                str(item["dataset_id"]), str(item["method"]), int(item["aggregate_count"]),
+                str(item["results_sha256"]), str(item["cold_sha256"]),
+            ))
+        if int(receipt.get("verified_pair_count", -1)) != 12 or len(claimed) != 12:
+            raise ValueError("First12 campaign receipt does not cover exactly 12 pairs")
+    else:
+        for item in receipt.get("datasets", []):
+            claimed.append((
+                str(item["dataset_id"]), "LZG", int(item["aggregate_count"]),
+                str(item["results"]["sha256"]), str(item["cold"]["sha256"]),
+            ))
+        if int(receipt.get("dataset_count", -1)) != 4 or len(claimed) != 4:
+            raise ValueError("LZG campaign receipt does not cover exactly four pairs")
+    if len({(dataset, method) for dataset, method, *_ in claimed}) != len(claimed):
+        raise ValueError(f"Campaign receipt contains duplicate pair identities: {path}")
+    for dataset, method, count, result_sha, cold_sha in claimed:
+        pair = by_identity.get((dataset, method))
+        if pair is None:
+            raise ValueError(f"Campaign receipt claims a pair absent from the import: {dataset}/{method}")
+        if pair["expected_rows"] != count:
+            raise ValueError(f"Campaign receipt aggregate count mismatch: {dataset}/{method}")
+        require_hash(pair["results_path"], result_sha, "campaign-bound result")
+        require_hash(pair["cold_path"], cold_sha, "campaign-bound cold result")
+    aggregate_count = sum(item[2] for item in claimed)
+    if int(receipt.get("aggregate_count", -1)) != aggregate_count:
+        raise ValueError(f"Campaign receipt aggregate total mismatch: {path}")
+    return {
+        "path": public_path(path), "sha256": sha256(path), "schema": receipt.get("schema"),
+        "status": status, "coverage_bound": True, "pair_count": len(claimed),
+        "aggregate_count": aggregate_count,
+    }
+
+
+def validate_pair(pair: dict[str, Any], host: str) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    results = read_jsonl(pair["results_path"])
+    cold = read_jsonl(pair["cold_path"])
+    if len(results) != pair["expected_rows"] or len(cold) != pair["expected_rows"]:
+        raise ValueError(f"Row-count mismatch for {pair['dataset']} / {pair['method']}")
+    if any(row.get("status") != "ok" for row in results + cold):
+        raise ValueError(f"Non-ok row for {pair['dataset']} / {pair['method']}")
+    cold_by_id = {str(row["aggregate_id"]): row for row in cold}
+    if len(cold_by_id) != len(cold):
+        raise ValueError(f"Duplicate cold aggregate id for {pair['dataset']} / {pair['method']}")
+    seen: set[str] = set()
+    for row in results:
+        aggregate_id = str(row["aggregate_id"])
+        if aggregate_id in seen:
+            raise ValueError(f"Duplicate result aggregate id: {aggregate_id}")
+        seen.add(aggregate_id)
+        verification = cold_by_id.get(aggregate_id)
+        if verification is None:
+            raise ValueError(f"Missing cold verification for {aggregate_id}")
+        if verification.get("complete_frame_sha256") != row.get("complete_frame_sha256"):
+            raise ValueError(f"Cold frame mismatch for {aggregate_id}")
+        if str(row.get("dataset_id")) != pair["dataset"] or str(row.get("method")) != pair["method"]:
+            raise ValueError(f"Result identity mismatch for {aggregate_id}")
+        if str(verification.get("dataset_id")) != pair["dataset"] or str(verification.get("method")) != pair["method"]:
+            raise ValueError(f"Cold identity mismatch for {aggregate_id}")
+        original = finite(row["original_numeric_bytes"], positive=True)
+        compressed = finite(row["complete_frame_bytes"], positive=True)
+        ratio = finite(row["compression_ratio"], positive=True)
+        if not math.isclose(ratio, compressed / original, rel_tol=2e-12, abs_tol=0.0):
+            raise ValueError(f"Compression ratio mismatch for {aggregate_id}")
+        finite(row["compression_ns_per_logical_point"])
+        finite(row["decompression_ns_per_logical_point"])
+    return results, {
+        "dataset": pair["dataset"],
+        "method": pair["method"],
+        "host": host,
+        "row_count": len(results),
+        "results_sha256": sha256(pair["results_path"]),
+        "cold_sha256": sha256(pair["cold_path"]),
+        "verification_sha256": pair["verification_sha256"],
+        "source_kind": pair["source_kind"],
+    }
+
+
+def dtype_scope(dtype: str) -> str:
+    value = dtype.casefold()
+    if value.startswith("float"):
+        return "float"
+    if value.startswith("int") or value.startswith("uint"):
+        return "integer"
+    raise ValueError(f"Unsupported Native86 dtype: {dtype}")
+
+
+def rows_for_pair(results: list[dict[str, Any]], runtime: str) -> list[dict[str, Any]]:
+    first = results[0]
+    dataset = str(first["dataset_id"])
+    family = str(first["method"])
+    if family.casefold() == "glza":
+        raise ValueError("GLZA is excluded from the public benchmark")
+    method = str(first["configuration"])
+    groups: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in results:
+        if str(row["configuration"]) != method:
+            raise ValueError(f"Multiple configurations in one verified pair: {dataset} / {family}")
+        groups[dtype_scope(str(row["dtype"]))].append(row)
+        groups["overall"].append(row)
+    output: list[dict[str, Any]] = []
+    for scope, source in sorted(groups.items()):
+        original = sum(int(row["original_numeric_bytes"]) for row in source)
+        compressed = sum(int(row["complete_frame_bytes"]) for row in source)
+        point_count = sum(int(row["row_count"]) for row in source)
+        output.append({
+            "dataset": dataset,
+            "scope": scope,
+            "runtime": runtime,
+            "method": method,
+            "family": family,
+            "algorithm_variant": method,
+            "is_best_rate_in_family": True,
+            "original_size_bytes": original,
+            "compressed_size_bytes": compressed,
+            "point_count": point_count,
+            "compression_time_ns": sum(finite(row["compression_ns"]) for row in source),
+            "decompression_time_ns": sum(finite(row["decompression_ns"]) for row in source),
+            "compression_rate": compressed / original,
+            "compression_time_ns_per_point": sum(
+                finite(row["compression_ns_per_logical_point"]) for row in source
+            ) / len(source),
+            "decompression_time_ns_per_point": sum(
+                finite(row["decompression_ns_per_logical_point"]) for row in source
+            ) / len(source),
+            "timing_column_count": len(source),
+            "timing_aggregation": "column_mean",
+        })
+    return output
+
+
+def recompute(data: dict[str, Any]) -> None:
+    rows = data["dataset_results"]
+    configurations: dict[tuple[str, str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    family_candidates: dict[tuple[str, str, str, str], dict[str, Any]] = {}
+    for row in rows:
+        if row.get("point_count") is None:
+            row["point_count"] = row["original_size_bytes"] / 8.0
+        configurations[row["runtime"], row["scope"], row["family"], row["method"]].append(row)
+        key = row["runtime"], row["scope"], row["dataset"], row["family"]
+        previous = family_candidates.get(key)
+        if previous is None or row["compression_rate"] < previous["compression_rate"] or (
+            row["compression_rate"] == previous["compression_rate"]
+            and row["method"] < previous["method"]
+        ):
+            family_candidates[key] = row
+    families: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in family_candidates.values():
+        families[row["runtime"], row["scope"], row["family"]].append(row)
+    data["configuration_aggregates"] = [
+        _aggregate_rows(source, runtime=runtime, scope_key=scope, family=family,
+                        method=method, algorithm_variant=method)
+        for (runtime, scope, family, method), source in sorted(configurations.items())
+    ]
+    data["family_best_aggregates"] = [
+        _aggregate_rows(source, runtime=runtime, scope_key=scope, family=family,
+                        method=family, algorithm_variant=None)
+        for (runtime, scope, family), source in sorted(families.items())
+    ]
+
+
+def integrate(args: argparse.Namespace) -> dict[str, Any]:
+    data_path = args.data.resolve()
+    manifest_path = args.manifest.resolve()
+    data = read_json(data_path)
+    allowed = {str(item["key"]) for item in data["datasets"]}
+    if len(allowed) != 164:
+        raise ValueError("Apply the website164 scope before Native86 integration")
+    pairs = profile_pairs(args.profile_root, args.execution_host)
+    source_receipts: list[dict[str, Any]] = []
+    if args.next5_root:
+        next5, final_receipt = next5_pairs(args.next5_root.resolve(), args.execution_host)
+        pairs.extend(next5)
+        source_receipts.append({**final_receipt, "status": VERIFIED_PAIR_STATUS})
+    if args.native_inventory:
+        if not args.native_root:
+            raise ValueError("--native-root is required with --native-inventory")
+        native, inventory_receipt = inventory_pairs(
+            args.native_inventory.resolve(), args.native_root.resolve(), args.execution_host
+        )
+        pairs.extend(native)
+        source_receipts.append(inventory_receipt)
+    if args.adjudication_receipt:
+        source_receipts.append(adjudication_receipt(args.adjudication_receipt.resolve(), pairs, args.execution_host))
+    for receipt_path in args.campaign_receipt:
+        source_receipts.append(campaign_receipt(receipt_path, pairs, args.execution_host))
+    if not pairs:
+        raise ValueError("No verified Native86 pairs were discovered")
+    identities: set[tuple[str, str]] = set()
+    new_rows: list[dict[str, Any]] = []
+    admitted: list[dict[str, Any]] = []
+    for pair in pairs:
+        identity = pair["dataset"], pair["method"]
+        if identity in identities:
+            raise ValueError(f"Duplicate verified pair: {identity}")
+        identities.add(identity)
+        if pair["dataset"] not in allowed:
+            raise ValueError(f"Native86 result is outside website164: {pair['dataset']}")
+        results, record = validate_pair(pair, args.execution_host)
+        new_rows.extend(rows_for_pair(results, args.runtime))
+        admitted.append(record)
+    replacement_keys = {
+        (row["dataset"], row["scope"], row["runtime"], row["method"]) for row in new_rows
+    }
+    old_rows = data["dataset_results"]
+    retained = [
+        row for row in old_rows
+        if (row["dataset"], row["scope"], row["runtime"], row["method"]) not in replacement_keys
+        and str(row.get("family", "")).casefold() != "glza"
+        and "glza" not in str(row.get("method", "")).casefold()
+    ]
+    data["dataset_results"] = sorted(
+        retained + new_rows,
+        key=lambda row: (row["dataset"], row["scope"], row["runtime"], row["family"], row["method"]),
+    )
+    recompute(data)
+    runtime_list = list(data["benchmark"].get("implementation_runtimes", []))
+    if args.runtime not in runtime_list:
+        runtime_list.append(args.runtime)
+    data["benchmark"]["implementation_runtimes"] = runtime_list
+    data["benchmark"]["publication_note"] = (
+        "All Native86 rows require hash-bound matching benchmark and fresh-cold results. "
+        "The server-192 cohort also carries independent pair-verification receipts; the "
+        "server-166 cohort carries strict source/admission or fresh-cold recovery receipts. "
+        "Execution hosts use separate runtime cohorts."
+    )
+    if args.adjudication_receipt:
+        data["benchmark"]["publication_note"] += (
+            " An independent Native166 evidence review adjudicated 773 of 920 pairs; "
+            "147 recovery-source pairs remain blocked because expected gate artifacts were not bundled."
+        )
+    boundary = (
+        "Native86 timings from server 166 and server 192 remain separate runtime cohorts and are never pooled."
+    )
+    if boundary not in data["benchmark"].setdefault("measurement_boundaries", []):
+        data["benchmark"]["measurement_boundaries"].append(boundary)
+    existing_methods = {(item["name"], item["family"]): item for item in data["methods"]}
+    family_examples: dict[str, dict[str, Any]] = {}
+    for item in data["methods"]:
+        family_examples.setdefault(str(item["family"]), item)
+    for row in new_rows:
+        key = row["method"], row["family"]
+        if key not in existing_methods:
+            example = family_examples.get(row["family"], {})
+            item = {
+                "name": row["method"], "family": row["family"], "runtimes": [args.runtime],
+                "operator_pipeline": example.get("operator_pipeline"),
+                "operator_pipeline_status": example.get("operator_pipeline_status", "not_available"),
+            }
+            data["methods"].append(item)
+            existing_methods[key] = item
+        elif args.runtime not in existing_methods[key].setdefault("runtimes", []):
+            existing_methods[key]["runtimes"].append(args.runtime)
+    data["methods"] = sorted(data["methods"], key=lambda item: (item["family"], item["name"]))
+    source = data["source"]
+    evidence_tier = (
+        "independent_pair_verification_and_hash_bound_fresh_cold"
+        if not args.native_inventory
+        else (
+            "partial_independent_adjudication_773_of_920_with_147_gate_artifact_blocked"
+            if args.adjudication_receipt
+            else "hash_bound_fresh_cold_with_strict_or_recovery_source_receipt"
+        )
+    )
+    source.setdefault("measurement_runs", []).append({
+        "schema": "site-native86-receipt-bound-import-v1",
+        "integrated_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "runtime": args.runtime,
+        "execution_host": args.execution_host,
+        "pair_count": len(admitted),
+        "aggregate_count": sum(item["row_count"] for item in admitted),
+        "families": sorted({item["method"] for item in admitted}),
+        "datasets": sorted({item["dataset"] for item in admitted}),
+        "source_receipts": [dict(item) for item in source_receipts],
+        "pair_receipts": admitted,
+        "evidence_tier": evidence_tier,
+        "source_kind_counts": dict(sorted(Counter(item["source_kind"] for item in admitted).items())),
+        "timing_comparability": f"within_{args.runtime}_only",
+    })
+    native_runs = [
+        run for run in source["measurement_runs"]
+        if run.get("schema") == "site-native86-receipt-bound-import-v1"
+    ]
+    native_by_runtime = {
+        run["runtime"]: {
+            "execution_host": run["execution_host"],
+            "pair_count": run["pair_count"],
+            "aggregate_count": run["aggregate_count"],
+            "evidence_tier": run["evidence_tier"],
+            "source_kind_counts": run["source_kind_counts"],
+        }
+        for run in native_runs
+    }
+    coverage = data["coverage"]
+    coverage.update(
+        dataset_count=164,
+        catalog_dataset_count=164,
+        measured_dataset_count=len({row["dataset"] for row in data["dataset_results"]}),
+        runtime_count=len({row["runtime"] for row in data["dataset_results"]}),
+        runtimes=sorted({row["runtime"] for row in data["dataset_results"]}),
+        dataset_result_row_count=len(data["dataset_results"]),
+        configuration_aggregate_row_count=len(data["configuration_aggregates"]),
+        family_best_aggregate_row_count=len(data["family_best_aggregates"]),
+        method_family_count=len({row["family"] for row in data["dataset_results"]}),
+        method_configuration_count=len({row["method"] for row in data["dataset_results"]}),
+        runtime_configuration_count=len({(row["runtime"], row["method"]) for row in data["dataset_results"]}),
+        timing_column_observation_count=sum(row.get("timing_column_count", 0) for row in data["dataset_results"]),
+        timing_column_mean_dataset_result_count=sum(row.get("timing_aggregation") == "column_mean" for row in data["dataset_results"]),
+        timing_dataset_aggregate_result_count=sum(row.get("timing_aggregation") == "dataset_aggregate" for row in data["dataset_results"]),
+        timing_unavailable_dataset_result_count=sum(row.get("timing_aggregation") == "unavailable" for row in data["dataset_results"]),
+        native86_verified_pair_count=sum(item["pair_count"] for item in native_by_runtime.values()),
+        native86_verified_aggregate_count=sum(item["aggregate_count"] for item in native_by_runtime.values()),
+        native86_verified_by_runtime=native_by_runtime,
+    )
+    data_path.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    manifest = read_json(manifest_path)
+    manifest.update(
+        data_sha256=sha256(data_path),
+        counts=coverage,
+        native86_imports=native_by_runtime,
+    )
+    manifest_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    receipt = {
+        "schema": "site-native86-integration-receipt-v1",
+        "status": "passed",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "runtime": args.runtime,
+        "execution_host": args.execution_host,
+        "pair_count": len(admitted),
+        "aggregate_count": sum(item["row_count"] for item in admitted),
+        "dataset_result_rows_added": len(new_rows),
+        "data_sha256": sha256(data_path),
+        "manifest_sha256": sha256(manifest_path),
+        "admitted_pairs": admitted,
+        "source_receipts": [dict(item) for item in source_receipts],
+    }
+    args.receipt.parent.mkdir(parents=True, exist_ok=True)
+    args.receipt.write_text(
+        json.dumps(receipt, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    return receipt
+
+
+def parser() -> argparse.ArgumentParser:
+    root = Path(__file__).resolve().parent
+    value = argparse.ArgumentParser(description=__doc__)
+    value.add_argument("--data", type=Path, default=root / "data.json")
+    value.add_argument("--manifest", type=Path, default=root / "manifest.json")
+    value.add_argument("--runtime", required=True)
+    value.add_argument("--execution-host", required=True)
+    value.add_argument("--profile-root", type=Path, action="append", default=[])
+    value.add_argument("--next5-root", type=Path)
+    value.add_argument("--native-inventory", type=Path)
+    value.add_argument("--native-root", type=Path)
+    value.add_argument("--adjudication-receipt", type=Path)
+    value.add_argument("--campaign-receipt", type=Path, action="append", default=[])
+    value.add_argument("--receipt", type=Path, required=True)
+    return value
+
+
+def main() -> int:
+    args = parser().parse_args()
+    receipt = integrate(args)
+    print(json.dumps({
+        "status": receipt["status"], "pairs": receipt["pair_count"],
+        "aggregates": receipt["aggregate_count"], "data_sha256": receipt["data_sha256"],
+    }, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

legacy-dbp-medium-posts-independent-review.json

@@ -0,0 +1,132 @@
+{
+  "acceptance_status": "provisional",
+  "aggregate_id": "medium_posts|timestamp|published",
+  "audit_scope": "deterministic receipt and integration-overlay review; no benchmark rerun",
+  "dataset": "medium_posts",
+  "input": {
+    "block_rows": [
+      10000,
+      10000,
+      10000,
+      10000,
+      10000,
+      10000,
+      10000,
+      10000,
+      10000,
+      2191
+    ],
+    "logical_blocks": 10,
+    "native_bytes": 737528,
+    "native_i64le_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+    "point_count": 92191,
+    "source_data_sha256": "5942f3ce0c6d78e0698193486b8a9a138dc1b8694bb24af701051403daca4a29"
+  },
+  "input_receipt_sha256": "109f8abe5be52e8c88a3cfa7e680e6f5a5e420698cbe360071b179305c5eb167",
+  "integration_overlay": {
+    "keys": [
+      [
+        "medium_posts",
+        "DBP",
+        "DELTA_BINARY_PACKED",
+        "cpp",
+        "integer"
+      ],
+      [
+        "medium_posts",
+        "DBP",
+        "DELTA_BINARY_PACKED",
+        "cpp",
+        "overall"
+      ],
+      [
+        "medium_posts",
+        "DBP",
+        "DELTA_BINARY_PACKED",
+        "java",
+        "integer"
+      ],
+      [
+        "medium_posts",
+        "DBP",
+        "DELTA_BINARY_PACKED",
+        "java",
+        "overall"
+      ],
+      [
+        "medium_posts",
+        "DBP",
+        "DELTA_BINARY_PACKED",
+        "python",
+        "integer"
+      ],
+      [
+        "medium_posts",
+        "DBP",
+        "DELTA_BINARY_PACKED",
+        "python",
+        "overall"
+      ]
+    ],
+    "row_count": 6,
+    "timing_aggregation": "column_mean",
+    "timing_column_count": 1,
+    "unique_key_count": 6
+  },
+  "integration_payload_sha256": "e45170a955d1cd0df50dba25f9e41f24f00fc8b559e702d59188b6cfa60c99dc",
+  "limitations": [
+    "Receipt-level audit cannot reread the remote frozen source files or rerun the benchmark.",
+    "Timing uses one measured repetition per runtime after warmup; it is a formal run but not a variance estimate.",
+    "Final data.json integration is checked separately after the rebuild completes."
+  ],
+  "measurement": {
+    "clean_process_list_before_after_identical": true,
+    "compressed_size_bytes": 615712,
+    "cpu": 37,
+    "decoded_sha256_equals_input_all_runtimes": true,
+    "excluded_cpu36_diagnostic_contains_av1_controller": true,
+    "payload_sha256_all_runtimes": "39214295d7739f2417d73b4cc9bb8771a228268500f3dab5a03eacdf7b4aea23",
+    "repetitions": 1,
+    "runtime_results": {
+      "cpp": {
+        "compression_time_ns": 1561143,
+        "compression_time_ns_per_point": 16.93378963239362,
+        "decompression_time_ns": 982881,
+        "decompression_time_ns_per_point": 10.661355229903135,
+        "result_sha256": "c13f5774a8f3ae4bfd4014ef87223adc3a8f0b67759269e9780e499a5e6bbd69"
+      },
+      "java": {
+        "compression_time_ns": 25658693,
+        "compression_time_ns_per_point": 278.32101832066036,
+        "decompression_time_ns": 5378995,
+        "decompression_time_ns_per_point": 58.34620516102439,
+        "result_sha256": "15ae6623e26e29c1dddba9fd0e1bda5dcb12d3f177ebd5a1dce46d75a7cd3d92"
+      },
+      "python": {
+        "compression_time_ns": 122842354,
+        "compression_time_ns_per_point": 1332.4766408868545,
+        "decompression_time_ns": 211613685,
+        "decompression_time_ns_per_point": 2295.383334598822,
+        "result_sha256": "8a628e63b2bcb2eda373bd0017b3782c4bb4951f83f88dae3b5e1c33a72a63b1"
+      }
+    },
+    "warmup_blocks": 10
+  },
+  "measurement_receipt_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+  "review_independence": "independent read-only subagent; same model family",
+  "runner_hashes_verified": {
+    "AlgorithmAllowList.java": "5d4a840e3faf2955e648ddef2f6f065a51f27456e410a97e94164c70ac6607e0",
+    "DbpIntBench.java": "a971886ea4518582ca538c0292ca9296dc54b429ce64e677560651f312e68f4a",
+    "dbp_int_cpp.cpp": "44e561eb6ed507205e1325a92e85233fb5ef8643fce6a5e4192b28eb263c1f40",
+    "dbp_int_python.py": "625c52136328e0f4d252dfc88c52f036470bb5094c05ca4b262fc4dbc57adcfd",
+    "prepare_input.py": "915d539949e505e8c89c734a339e037d49b68cdb2b1bf5f9cf8a7d0158cec0a6"
+  },
+  "schema": "dbp-medium-posts-independent-audit-v1",
+  "source_hashes_verified_against_git_revision": {
+    "backend/myapp/column_encodings.py": "339f96a8fbb4aa6b3da1e512ffc6e83d0538fb957e2ef310c8b42aae3d9af021",
+    "cpp/src/column_encodings.cpp": "ee1f6de0a8b9287d8118aaeb790b985e6b604acca142746685ea038cb9e5d59a",
+    "java/src/main/java/org/example/ColumnarEncodings.java": "0e2878cb2f31c88f100d59117d742d81efd1afe6bc1a349e16687ae4573575d3"
+  },
+  "source_revision": "cd1b55b7441a45010645451fd3149553c6d419cc",
+  "status": "passed"
+}

legacy-dbp-medium-posts-timing-receipt.json

@@ -0,0 +1,463 @@
+{
+  "aggregate_id": "medium_posts|timestamp|published",
+  "benchmark_contract": {
+    "block_state": "reset for every frozen logical block",
+    "codec": "project delta + ZigZag + ULEB128 int64 wire",
+    "column_count": 1,
+    "cpu_affinity": [
+      37
+    ],
+    "governor": "schedutil",
+    "logical_blocks": 10,
+    "method": "DELTA_BINARY_PACKED",
+    "repetitions": 1,
+    "shared_server": true,
+    "timing": "encode and decode timed per block; block nanoseconds summed",
+    "timing_aggregation": "column_mean",
+    "warmup": "first min(20, logical_block_count) blocks once, metrics discarded",
+    "warmup_blocks_executed": 10
+  },
+  "build": {
+    "cpp_binary": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/build/cpp/dbp_int_cpp",
+      "sha256": "84520ca85b662179cb7e21ae586584350559e3dd2acd0ce0b34f189d1ef09aef"
+    },
+    "cpp_flags": "-O3 -DNDEBUG -std=c++20",
+    "java_main_class": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/build/java/org/example/DbpIntBench.class",
+      "sha256": "d982c23c526a7992241e4700b389da176eeff846072446e6888489eec9aa6210"
+    },
+    "java_runtime": "/usr/lib/jvm/java-17-openjdk-amd64/bin/java"
+  },
+  "created_at_utc": "2026-10-09T07:18:00.197252+00:00",
+  "cross_runtime_golden": {
+    "all_runtime_compressed_size_bytes": 615712,
+    "all_runtime_decoded_i64le_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+    "all_runtime_payload_sha256": "39214295d7739f2417d73b4cc9bb8771a228268500f3dab5a03eacdf7b4aea23",
+    "historical_java_compressed_size_bytes": 615712,
+    "status": "passed"
+  },
+  "dataset": "medium_posts",
+  "environment": {
+    "cpu37_no_user_process_before_after": true,
+    "cpu37_processes_after_sha256": "7fcee621228a258ad0262e0bd4c7c3eb8f2452d685982e520a52a2b41cc01816",
+    "cpu37_processes_before_sha256": "7fcee621228a258ad0262e0bd4c7c3eb8f2452d685982e520a52a2b41cc01816",
+    "cpu_model": "AMD EPYC 7542 32-Core Processor",
+    "gxx": "g++ (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0",
+    "hostname": "server",
+    "java": "openjdk version \"17.0.16\" 2025-07-15",
+    "kernel": "5.15.0-152-generic",
+    "machine": "x86_64",
+    "python": "3.10.12"
+  },
+  "excluded_diagnostic": {
+    "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/diagnostic_attempt_cpu36",
+    "reason": "CPU36 preflight contained an unrelated AV1 controller process; all runtimes were rerun sequentially on clean CPU37"
+  },
+  "input": {
+    "aggregate_id": "medium_posts|timestamp|published",
+    "block_counts": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/input/block_counts.txt",
+      "sha256": "d81b8c81724430936b30ac1bf84c16e77937dd262e0c55268018d3754ee41aab"
+    },
+    "block_receipts": [
+      {
+        "block_index": 0,
+        "length": 80000,
+        "offset": 0,
+        "row_count": 10000,
+        "sha256": "910c80cb45d921944d5eb53f904db99aae194ec045f80c2333e13289ec25f4ad"
+      },
+      {
+        "block_index": 1,
+        "length": 80000,
+        "offset": 81250,
+        "row_count": 10000,
+        "sha256": "dd6b4dd2bccd96896e5c3edc1fd172cd282c4a4970be6728025778308fa00604"
+      },
+      {
+        "block_index": 2,
+        "length": 80000,
+        "offset": 162500,
+        "row_count": 10000,
+        "sha256": "1c7fdf4fa11ad6956af1015354a28593d8e659d50b4484a755733b721842e491"
+      },
+      {
+        "block_index": 3,
+        "length": 80000,
+        "offset": 243750,
+        "row_count": 10000,
+        "sha256": "60034782c26101401c21c38cd38c33abb44132cea5654de9cd968c61a795e51a"
+      },
+      {
+        "block_index": 4,
+        "length": 80000,
+        "offset": 325000,
+        "row_count": 10000,
+        "sha256": "26450ac64eef6012fca8076be0bd9e9e80693012157d6b268cb667e036d229ef"
+      },
+      {
+        "block_index": 5,
+        "length": 80000,
+        "offset": 406250,
+        "row_count": 10000,
+        "sha256": "dcda5838e0f00ebc74ad95fddf59783cd0ca4b44368c5daeb55ce6e3be66e193"
+      },
+      {
+        "block_index": 6,
+        "length": 80000,
+        "offset": 487500,
+        "row_count": 10000,
+        "sha256": "22b2af06f9080b6d6c78bcedcfa6769760c352e62c9f6170a3fa111c071e7692"
+      },
+      {
+        "block_index": 7,
+        "length": 80000,
+        "offset": 568750,
+        "row_count": 10000,
+        "sha256": "ce2292699691a031f9886dd94c9342a2ebf05f32aaaafd312ea31dc67ecc55c2"
+      },
+      {
+        "block_index": 8,
+        "length": 80000,
+        "offset": 650000,
+        "row_count": 10000,
+        "sha256": "5e643436f97ee4c7fce7968ad9256210fee9903115e6a19533e3183a80c1edbc"
+      },
+      {
+        "block_index": 9,
+        "length": 17528,
+        "offset": 731250,
+        "row_count": 2191,
+        "sha256": "05483b98a5501ebcb199160a8c4507ceaf1f73fe4e10e36393366fb37fd78d1c"
+      }
+    ],
+    "byte_order": "little",
+    "created_at_utc": "2026-10-09T07:14:36.412070+00:00",
+    "dataset": "medium_posts",
+    "derived_input": {
+      "bytes": 737528,
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/input/medium_posts_published.i64le",
+      "sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b"
+    },
+    "dtype": "int64",
+    "first_value": 1344898493510000,
+    "last_value": 1497250169954000,
+    "logical_block_count": 10,
+    "logical_type": "timestamp",
+    "maximum_value": 1498574922850000,
+    "minimum_value": 1000,
+    "missing_count": 0,
+    "native_bytes": 737528,
+    "native_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+    "row_count": 92191,
+    "schema": "dbp-medium-posts-input-v1",
+    "source_data_sha256": "5942f3ce0c6d78e0698193486b8a9a138dc1b8694bb24af701051403daca4a29",
+    "source_paths": {
+      "READY.json": {
+        "identity": {
+          "bytes": 1059,
+          "ctime_ns": 1791402334374446073,
+          "device": 66304,
+          "inode": 112864917,
+          "mtime_ns": 1791402334374446073,
+          "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/core19_typed_segments_v1/datasets/medium_posts/READY.json"
+        },
+        "sha256": "63be0b1dfb6726c92a2f8a5ee747f75908fbe13167108c1598586e6dbddcd214"
+      },
+      "dataset_manifest.json": {
+        "identity": {
+          "bytes": 7744,
+          "ctime_ns": 1791402334374446073,
+          "device": 66304,
+          "inode": 112864916,
+          "mtime_ns": 1791402334374446073,
+          "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/core19_typed_segments_v1/datasets/medium_posts/dataset_manifest.json"
+        },
+        "sha256": "9ceb1dbbcc5c8708c0f63f8d7e913b56a4fe30d2aa6f70255dc334e968c90a4e"
+      },
+      "full/blocks.jsonl": {
+        "identity": {
+          "bytes": 25939,
+          "ctime_ns": 1791402334370446042,
+          "device": 66304,
+          "inode": 112864912,
+          "mtime_ns": 1791402334370446042,
+          "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/core19_typed_segments_v1/datasets/medium_posts/full/blocks.jsonl"
+        },
+        "sha256": "a0ed3e9b2b42de7240a3f0b640f95de1179deb52f08e03fb2865c272d2cbf370"
+      },
+      "full/payload/shard-000000.bin": {
+        "identity": {
+          "bytes": 749052,
+          "ctime_ns": 1791402334370446042,
+          "device": 66304,
+          "inode": 112864861,
+          "mtime_ns": 1791402334370446042,
+          "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/core19_typed_segments_v1/datasets/medium_posts/full/payload/shard-000000.bin"
+        },
+        "sha256": "661e44a118069fa9ab60d7bb4a20478de85281a13edebf3abf133f9a5637684f"
+      }
+    },
+    "source_read_only_identity_before_after": "passed",
+    "status": "passed",
+    "valid_count": 92191
+  },
+  "output_files": {
+    "cpp": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/results/cpp.json",
+      "sha256": "c13f5774a8f3ae4bfd4014ef87223adc3a8f0b67759269e9780e499a5e6bbd69"
+    },
+    "input_receipt": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/input/input_receipt.json",
+      "sha256": "109f8abe5be52e8c88a3cfa7e680e6f5a5e420698cbe360071b179305c5eb167"
+    },
+    "java": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/results/java.json",
+      "sha256": "15ae6623e26e29c1dddba9fd0e1bda5dcb12d3f177ebd5a1dce46d75a7cd3d92"
+    },
+    "python": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/results/python.json",
+      "sha256": "8a628e63b2bcb2eda373bd0017b3782c4bb4951f83f88dae3b5e1c33a72a63b1"
+    }
+  },
+  "runner_files": {
+    "AlgorithmAllowList.java": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/AlgorithmAllowList.java",
+      "sha256": "5d4a840e3faf2955e648ddef2f6f065a51f27456e410a97e94164c70ac6607e0"
+    },
+    "DbpIntBench.java": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/DbpIntBench.java",
+      "sha256": "a971886ea4518582ca538c0292ca9296dc54b429ce64e677560651f312e68f4a"
+    },
+    "dbp_int_cpp.cpp": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/dbp_int_cpp.cpp",
+      "sha256": "44e561eb6ed507205e1325a92e85233fb5ef8643fce6a5e4192b28eb263c1f40"
+    },
+    "dbp_int_python.py": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/dbp_int_python.py",
+      "sha256": "625c52136328e0f4d252dfc88c52f036470bb5094c05ca4b262fc4dbc57adcfd"
+    },
+    "prepare_input.py": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/prepare_input.py",
+      "sha256": "915d539949e505e8c89c734a339e037d49b68cdb2b1bf5f9cf8a7d0158cec0a6"
+    }
+  },
+  "runtime_results": {
+    "cpp": {
+      "block_state_policy": "reset codec state for every frozen logical block",
+      "clock": "std::chrono::steady_clock",
+      "column_compression_ns_per_point": [
+        16.93378963239362
+      ],
+      "column_count": 1,
+      "column_decompression_ns_per_point": [
+        10.661355229903135
+      ],
+      "column_mean_compression_ns_per_point": 16.93378963239362,
+      "column_mean_decompression_ns_per_point": 10.661355229903135,
+      "compressed_size_bytes": 615712,
+      "compression_block_time_ns": [
+        172175,
+        157197,
+        157717,
+        156324,
+        183596,
+        169790,
+        179809,
+        172335,
+        172635,
+        39565
+      ],
+      "compression_ns_per_point": 16.93378963239362,
+      "compression_time_ns": 1561143,
+      "compression_time_ns_samples": [
+        1561143
+      ],
+      "decoded_i64le_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+      "decompression_block_time_ns": [
+        83447,
+        180099,
+        84509,
+        83387,
+        105509,
+        97614,
+        115698,
+        104056,
+        104327,
+        24235
+      ],
+      "decompression_ns_per_point": 10.661355229903135,
+      "decompression_time_ns": 982881,
+      "decompression_time_ns_samples": [
+        982881
+      ],
+      "implementation_symbols": [
+        "colenc::encode_delta_zigzag_varint_int64_impl",
+        "colenc::decode_delta_zigzag_varint_int64_impl"
+      ],
+      "logical_block_count": 10,
+      "original_size_bytes": 737528,
+      "payload_sha256": "39214295d7739f2417d73b4cc9bb8771a228268500f3dab5a03eacdf7b4aea23",
+      "point_count": 92191,
+      "repetitions": 1,
+      "runtime": "cpp",
+      "schema": "dbp-medium-posts-runtime-v2",
+      "status": "passed",
+      "validation": "decoded int64 little-endian bytes exactly equal input bytes",
+      "warmup_blocks_executed": 10,
+      "warmup_policy": "first_min_20_blocks_once_then_reset_metrics"
+    },
+    "java": {
+      "block_state_policy": "reset codec state for every frozen logical block",
+      "clock": "System.nanoTime",
+      "column_compression_ns_per_point": [
+        278.32101832066036
+      ],
+      "column_count": 1,
+      "column_decompression_ns_per_point": [
+        58.34620516102439
+      ],
+      "column_mean_compression_ns_per_point": 278.32101832066036,
+      "column_mean_decompression_ns_per_point": 58.34620516102439,
+      "compressed_size_bytes": 615712,
+      "compression_block_time_ns": [
+        22615576,
+        404643,
+        396908,
+        385727,
+        394133,
+        377702,
+        378774,
+        320374,
+        315435,
+        69421
+      ],
+      "compression_ns_per_point": 278.32101832066036,
+      "compression_time_ns": 25658693,
+      "compression_time_ns_samples": [
+        25658693
+      ],
+      "decoded_i64le_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+      "decompression_block_time_ns": [
+        588650,
+        523075,
+        515532,
+        939871,
+        505011,
+        523827,
+        558953,
+        570746,
+        528926,
+        124404
+      ],
+      "decompression_ns_per_point": 58.34620516102439,
+      "decompression_time_ns": 5378995,
+      "decompression_time_ns_samples": [
+        5378995
+      ],
+      "implementation_symbols": [
+        "org.example.ColumnarEncodings.encodeDeltaZigZagVarintLong",
+        "org.example.ColumnarEncodings.decodeDeltaZigZagVarintLong"
+      ],
+      "logical_block_count": 10,
+      "original_size_bytes": 737528,
+      "payload_sha256": "39214295d7739f2417d73b4cc9bb8771a228268500f3dab5a03eacdf7b4aea23",
+      "point_count": 92191,
+      "repetitions": 1,
+      "runtime": "java",
+      "schema": "dbp-medium-posts-runtime-v2",
+      "status": "passed",
+      "validation": "decoded int64 little-endian bytes exactly equal input bytes",
+      "warmup_blocks_executed": 10,
+      "warmup_policy": "first_min_20_blocks_once_then_reset_metrics"
+    },
+    "python": {
+      "block_state_policy": "reset codec state for every frozen logical block",
+      "clock": "time.perf_counter_ns",
+      "column_compression_ns_per_point": [
+        1332.4766408868545
+      ],
+      "column_count": 1,
+      "column_decompression_ns_per_point": [
+        2295.383334598822
+      ],
+      "column_mean_compression_ns_per_point": 1332.4766408868545,
+      "column_mean_decompression_ns_per_point": 2295.383334598822,
+      "compressed_size_bytes": 615712,
+      "compression_block_time_ns": [
+        13422193,
+        13535837,
+        13357160,
+        13450796,
+        13493147,
+        13246983,
+        13155771,
+        13151712,
+        13195105,
+        2833650
+      ],
+      "compression_ns_per_point": 1332.4766408868545,
+      "compression_time_ns": 122842354,
+      "compression_time_ns_samples": [
+        122842354
+      ],
+      "decoded_i64le_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+      "decompression_block_time_ns": [
+        23098266,
+        23341575,
+        23161446,
+        23239062,
+        23105350,
+        22768595,
+        22707009,
+        22645002,
+        22543972,
+        5003408
+      ],
+      "decompression_ns_per_point": 2295.383334598822,
+      "decompression_time_ns": 211613685,
+      "decompression_time_ns_samples": [
+        211613685
+      ],
+      "implementation_symbols": [
+        "backend.myapp.column_encodings.encode_delta_zigzag_varint_int",
+        "backend.myapp.column_encodings.decode_delta_zigzag_varint_int"
+      ],
+      "logical_block_count": 10,
+      "original_size_bytes": 737528,
+      "payload_sha256": "39214295d7739f2417d73b4cc9bb8771a228268500f3dab5a03eacdf7b4aea23",
+      "point_count": 92191,
+      "repetitions": 1,
+      "runtime": "python",
+      "schema": "dbp-medium-posts-runtime-v2",
+      "status": "passed",
+      "validation": "decoded int64 little-endian bytes exactly equal input bytes",
+      "warmup_blocks_executed": 10,
+      "warmup_policy": "first_min_20_blocks_once_then_reset_metrics"
+    }
+  },
+  "schema": "dbp-medium-posts-retest-receipt-v2",
+  "scope": "integer",
+  "source_files": {
+    "cpp_codec": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/cpp/src/column_encodings.cpp",
+      "sha256": "ee1f6de0a8b9287d8118aaeb790b985e6b604acca142746685ea038cb9e5d59a"
+    },
+    "java_codec": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/java/src/main/java/org/example/ColumnarEncodings.java",
+      "sha256": "0e2878cb2f31c88f100d59117d742d81efd1afe6bc1a349e16687ae4573575d3"
+    },
+    "python_codec": {
+      "path": "/data/user/new_ai_compress/operator_sweep/medium_posts_dbp_int_20261009_v1/runner/backend/myapp/column_encodings.py",
+      "sha256": "339f96a8fbb4aa6b3da1e512ffc6e83d0538fb957e2ef310c8b42aae3d9af021"
+    }
+  },
+  "source_revision": "cd1b55b7441a45010645451fd3149553c6d419cc",
+  "status": "passed",
+  "validation": {
+    "byte_for_byte_lossless": true,
+    "cross_runtime_payload_identical": true,
+    "frozen_input_source_identity": "passed"
+  }
+}

manifest.json

@@ -1,39 +1,303 @@
 {
   "counts": {
-    "catalog_dataset_count": 169,
-    "configuration_aggregate_row_count": 4653,
-    "dataset_count": 169,
-    "dataset_result_row_count": 65223,
+    "catalog_dataset_count": 164,
+    "configuration_aggregate_row_count": 4925,
+    "dataset_count": 164,
+    "dataset_result_row_count": 90897,
     "excluded_datasets": [
       "Arade",
+      "app_flow",
+      "ethereum_signals_sample",
+      "github_top_developers",
       "poisson_timestamps",
       "supply_chain_customer",
-      "supply_chain_location"
+      "supply_chain_location",
+      "tiktok_trending_hashtags_music",
+      "youtube_trending_2019_2020"
     ],
-    "family_best_aggregate_row_count": 1383,
+    "family_best_aggregate_row_count": 1646,
     "measured_dataset_count": 164,
-    "method_configuration_count": 311,
-    "method_family_count": 93,
+    "method_configuration_count": 401,
+    "method_family_count": 104,
     "missing_measurement_policy": "Missing report and dataset/scope/runtime/configuration combinations are omitted; the UI must display them as unavailable, never as zero.",
     "missing_source_report_count": 0,
+    "native86_accepted_repair_overlap_pair_count": 1,
+    "native86_accepted_unique_repair_pair_count": 174,
+    "native86_comparison_profiles": {
+      "cpp-native166-main-458a218f": {
+        "dataset_result_count": 25443,
+        "exact_source_profiles": [
+          "cpp-native166-main-458a218f"
+        ],
+        "execution_host": "166.111.68.166",
+        "pair_count": 11164,
+        "timing_admitted": true
+      },
+      "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 383,
+        "exact_source_profiles": [
+          "cpp-native166-recovery-3452a998",
+          "cpp-native166-recovery-39dc8c5d",
+          "cpp-native166-recovery-458a218f",
+          "cpp-native166-recovery-813812e1",
+          "cpp-native166-recovery-82297044",
+          "cpp-native166-recovery-9abdc80f"
+        ],
+        "execution_host": "166.111.68.166",
+        "pair_count": 154,
+        "timing_admitted": false
+      },
+      "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 29,
+        "exact_source_profiles": [
+          "cpp-native192-first12-3452a998",
+          "cpp-native192-first12-39dc8c5d",
+          "cpp-native192-first12-9abdc80f",
+          "cpp-native192-first12-bf0a069f"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 12,
+        "timing_admitted": false
+      },
+      "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2": {
+        "dataset_result_count": 5,
+        "exact_source_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-41d0e8fc"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_admitted": false
+      },
+      "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1": {
+        "dataset_result_count": 6,
+        "exact_source_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-00f34de8"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_admitted": false
+      },
+      "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 15,
+        "exact_source_profiles": [
+          "cpp-native192-next5-39dc8c5d",
+          "cpp-native192-next5-9abdc80f",
+          "cpp-native192-next5-bf0a069f"
+        ],
+        "execution_host": "192.168.99.20",
+        "pair_count": 5,
+        "timing_admitted": false
+      }
+    },
+    "native86_host192_independently_verified_pair_count": 21,
+    "native86_main_all_na_pair_count": 2274,
+    "native86_main_numeric_pair_count": 11164,
+    "native86_main_problem_pair_count": 502,
+    "native86_profiles": {
+      "cpp-native166-main-458a218f": {
+        "aggregate_count": 290745,
+        "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+        "comparison_profiles": [
+          "cpp-native166-main-458a218f"
+        ],
+        "dataset_result_count": 25443,
+        "execution_host": "166.111.68.166",
+        "pair_count": 11164,
+        "timing_profile_status": "timing_admitted_frozen_source_build_binary_boundary_bound"
+      },
+      "cpp-native166-recovery-3452a998": {
+        "aggregate_count": 2157,
+        "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 119,
+        "execution_host": "166.111.68.166",
+        "pair_count": 48,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-39dc8c5d": {
+        "aggregate_count": 1178,
+        "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 141,
+        "execution_host": "166.111.68.166",
+        "pair_count": 57,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-458a218f": {
+        "aggregate_count": 642,
+        "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 14,
+        "execution_host": "166.111.68.166",
+        "pair_count": 6,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-813812e1": {
+        "aggregate_count": 163,
+        "binary_sha256": "813812e15013991a809e82fafe710aae77e29c96fa5d2d9101d8323a9cd07e30",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "166.111.68.166",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-82297044": {
+        "aggregate_count": 39,
+        "binary_sha256": "822970447c25f2b5f18e2d750c2a9407b6a23f22cb9f59c40565273599e20fc0",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 2,
+        "execution_host": "166.111.68.166",
+        "pair_count": 1,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native166-recovery-9abdc80f": {
+        "aggregate_count": 1117,
+        "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+        "comparison_profiles": [
+          "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 101,
+        "execution_host": "166.111.68.166",
+        "pair_count": 40,
+        "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+      },
+      "cpp-native192-first12-3452a998": {
+        "aggregate_count": 493,
+        "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 5,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-first12-39dc8c5d": {
+        "aggregate_count": 568,
+        "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 10,
+        "execution_host": "192.168.99.20",
+        "pair_count": 4,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-first12-9abdc80f": {
+        "aggregate_count": 148,
+        "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 11,
+        "execution_host": "192.168.99.20",
+        "pair_count": 5,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-first12-bf0a069f": {
+        "aggregate_count": 66,
+        "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+        "comparison_profiles": [
+          "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 3,
+        "execution_host": "192.168.99.20",
+        "pair_count": 1,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-lzg-level5-fastfalse-00f34de8": {
+        "aggregate_count": 140,
+        "binary_sha256": "00f34de8d145e114d19bc592935fe33b241394692c4a28fd9b8597d809dd3351",
+        "comparison_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-lzg-level5-fastfalse-41d0e8fc": {
+        "aggregate_count": 56,
+        "binary_sha256": "41d0e8fc01f94ffa9d2f07796f7fc1bc45a194491535ec927ef627d663f62b08",
+        "comparison_profiles": [
+          "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2"
+        ],
+        "dataset_result_count": 5,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-next5-39dc8c5d": {
+        "aggregate_count": 118,
+        "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+        "comparison_profiles": [
+          "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-next5-9abdc80f": {
+        "aggregate_count": 44,
+        "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+        "comparison_profiles": [
+          "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 3,
+        "execution_host": "192.168.99.20",
+        "pair_count": 1,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      },
+      "cpp-native192-next5-bf0a069f": {
+        "aggregate_count": 118,
+        "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+        "comparison_profiles": [
+          "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 6,
+        "execution_host": "192.168.99.20",
+        "pair_count": 2,
+        "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+      }
+    },
+    "native86_terminal_pair_count": 13940,
+    "native86_unresolved_problem_pair_count": 328,
+    "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 931,
-    "runtime_count": 3,
+    "runtime_configuration_count": 1025,
+    "runtime_count": 9,
     "runtimes": [
       "cpp",
+      "cpp-native166-main-458a218f",
+      "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3",
+      "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3",
+      "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2",
+      "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1",
+      "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3",
       "java",
       "python"
     ],
     "scope_count": 5,
     "source_report_file_count": 108,
-    "timing_column_mean_dataset_result_count": 64771,
-    "timing_column_observation_count": 1435347,
-    "timing_dataset_aggregate_result_count": 452,
-    "timing_unavailable_dataset_result_count": 0
+    "timing_column_mean_dataset_result_count": 25449,
+    "timing_column_observation_count": 519087,
+    "timing_dataset_aggregate_result_count": 0,
+    "timing_unavailable_dataset_result_count": 65448
   },
   "data_file": "data.json",
-  "data_sha256": "727bf6a91dbb2bc8f63dd87122b8dc1db261589e4da742f28f0e52dad0616571",
-  "dataset_catalog_sha256": "d69abc85742dc050e4cdab1e5a03fd3392a0e0f1964b2a88ca87ba7f768b7385",
+  "data_sha256": "433a82416f865225818c96816934218cd6eb0a4b19cfc608cc5e0010b3c46eac",
+  "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
     "user uploads",
@@ -268,6 +532,242 @@
       "validation_status": "passed_byte_for_byte_lossless"
     }
   ],
+  "native86_imports": {
+    "cpp-native166-main-458a218f": {
+      "aggregate_count": 290745,
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "comparison_profiles": [
+        "cpp-native166-main-458a218f"
+      ],
+      "dataset_result_count": 25443,
+      "execution_host": "166.111.68.166",
+      "pair_count": 11164,
+      "timing_profile_status": "timing_admitted_frozen_source_build_binary_boundary_bound"
+    },
+    "cpp-native166-recovery-3452a998": {
+      "aggregate_count": 2157,
+      "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 119,
+      "execution_host": "166.111.68.166",
+      "pair_count": 48,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-39dc8c5d": {
+      "aggregate_count": 1178,
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 141,
+      "execution_host": "166.111.68.166",
+      "pair_count": 57,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-458a218f": {
+      "aggregate_count": 642,
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 14,
+      "execution_host": "166.111.68.166",
+      "pair_count": 6,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-813812e1": {
+      "aggregate_count": 163,
+      "binary_sha256": "813812e15013991a809e82fafe710aae77e29c96fa5d2d9101d8323a9cd07e30",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "166.111.68.166",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-82297044": {
+      "aggregate_count": 39,
+      "binary_sha256": "822970447c25f2b5f18e2d750c2a9407b6a23f22cb9f59c40565273599e20fc0",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 2,
+      "execution_host": "166.111.68.166",
+      "pair_count": 1,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-9abdc80f": {
+      "aggregate_count": 1117,
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 101,
+      "execution_host": "166.111.68.166",
+      "pair_count": 40,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native192-first12-3452a998": {
+      "aggregate_count": 493,
+      "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 5,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-first12-39dc8c5d": {
+      "aggregate_count": 568,
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 10,
+      "execution_host": "192.168.99.20",
+      "pair_count": 4,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-first12-9abdc80f": {
+      "aggregate_count": 148,
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 11,
+      "execution_host": "192.168.99.20",
+      "pair_count": 5,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-first12-bf0a069f": {
+      "aggregate_count": 66,
+      "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 3,
+      "execution_host": "192.168.99.20",
+      "pair_count": 1,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-lzg-level5-fastfalse-00f34de8": {
+      "aggregate_count": 140,
+      "binary_sha256": "00f34de8d145e114d19bc592935fe33b241394692c4a28fd9b8597d809dd3351",
+      "comparison_profiles": [
+        "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-lzg-level5-fastfalse-41d0e8fc": {
+      "aggregate_count": 56,
+      "binary_sha256": "41d0e8fc01f94ffa9d2f07796f7fc1bc45a194491535ec927ef627d663f62b08",
+      "comparison_profiles": [
+        "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2"
+      ],
+      "dataset_result_count": 5,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-next5-39dc8c5d": {
+      "aggregate_count": 118,
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "comparison_profiles": [
+        "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-next5-9abdc80f": {
+      "aggregate_count": 44,
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "comparison_profiles": [
+        "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 3,
+      "execution_host": "192.168.99.20",
+      "pair_count": 1,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-next5-bf0a069f": {
+      "aggregate_count": 118,
+      "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+      "comparison_profiles": [
+        "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    }
+  },
+  "native86_terminal_coverage": {
+    "coverage_receipt": {
+      "path": "native86-coverage.json",
+      "sha256": "3ad4905aee17e3f4d9d74df2d547bf17a1d8473ec9aab52dbe9c8f11b144cf50"
+    },
+    "independent_adjudication": {
+      "pair_path": "native86-main166-pair-adjudication.jsonl",
+      "pair_sha256": "f55be6435dd7ff90dd04777f693299e73a2ef42fdf0e59f58eb3f1aa247e8aab",
+      "path": "native86-main166-independent-adjudication.json",
+      "sha256": "ada06b5191e0edf92c862c68bb21562e7d46fbef014e71fb775a1b2b44dcf004",
+      "status": "partial_verification_blocked",
+      "status_counts": {
+        "independently_adjudicated": 773,
+        "not_independently_adjudicated_missing_expected_gate_artifact": 147
+      }
+    },
+    "legacy_dbp_medium_posts_timing": {
+      "admitted_dataset_result_rows": 6,
+      "independent_review": {
+        "path": "legacy-dbp-medium-posts-independent-review.json",
+        "sha256": "ec4095da7f99aebc07a4768cef15cba713a1b9e68a03d7ce41b23a9e7da3e5fd",
+        "source_sha256": "a200679cddddd96e7bd7488d499dcdeace7f098195e8ead502f70dc49af49043"
+      },
+      "receipt": {
+        "path": "legacy-dbp-medium-posts-timing-receipt.json",
+        "sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+        "source_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324"
+      }
+    },
+    "main_dataset_results": {
+      "path": "native86-main166-dataset-results.jsonl.gz",
+      "published_support_aware_rows": 25443,
+      "sha256": "a9e0e5b790ca8aa320d8696cb4af54835725401b0450fa980765534dc92b3c74",
+      "source_rows": 27151
+    },
+    "main_timing_proof": {
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "path": "native86-main166-timing-proof.json",
+      "schema": "paper164-old-main166-timing-provenance-readonly-v1",
+      "sha256": "f0f502d348fa20f336911f960efb63da07ddfbe922327acc636554e36d62590c",
+      "status": "passed"
+    },
+    "path": "native86-terminal-matrix.jsonl.gz",
+    "recovery_reconciliation": {
+      "accepted_unique_repair_pairs": 174,
+      "path": "native86-recovery-reconciliation.json",
+      "sha256": "39f05a3195a1aeb3ad23114322b40fa91a205e5f798e1ceb7598beb91ae7c0f2",
+      "unresolved_problem_pairs": 328
+    },
+    "rows": 13940,
+    "sha256": "1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9",
+    "v9_current154": {
+      "pairs": 154,
+      "path": "native86-v9-current154-thin.jsonl.gz",
+      "sha256": "f538e84dd2b4fee3c1b0d68408095fc88714eafe3ac0e6a57d6dc674f39e47a0"
+    }
+  },
+  "reference_catalog_sha256": "15fc0b3931c87bc7f3012b2cbd72b200fcbae811f159d200568af6fb45a10e88",
   "result_csv_files": [
     {
       "path": "backend/dataset/Air-Quality/Air-Quality_float_cpp_compression_result.csv",
@@ -823,6 +1323,12 @@
       "role": "reviewed_dataset_catalog",
       "sha256": "d69abc85742dc050e4cdab1e5a03fd3392a0e0f1964b2a88ca87ba7f768b7385",
       "status": "reviewed_public_catalog"
+    },
+    {
+      "path": "dataset-catalog.json",
+      "role": "reviewed_dataset_catalog",
+      "sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
+      "status": "reviewed_public_catalog"
     }
   ],
   "timing_recalculation": {

native86-coverage.json

@@ -0,0 +1,351 @@
+{
+  "accepted_repair_overlap_pair_count": 1,
+  "accepted_unique_repair_pair_count": 174,
+  "active_method_count": 85,
+  "comparison_profiles": {
+    "cpp-native166-main-458a218f": {
+      "dataset_result_count": 25443,
+      "exact_source_profiles": [
+        "cpp-native166-main-458a218f"
+      ],
+      "execution_host": "166.111.68.166",
+      "pair_count": 11164,
+      "timing_admitted": true
+    },
+    "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3": {
+      "dataset_result_count": 383,
+      "exact_source_profiles": [
+        "cpp-native166-recovery-3452a998",
+        "cpp-native166-recovery-39dc8c5d",
+        "cpp-native166-recovery-458a218f",
+        "cpp-native166-recovery-813812e1",
+        "cpp-native166-recovery-82297044",
+        "cpp-native166-recovery-9abdc80f"
+      ],
+      "execution_host": "166.111.68.166",
+      "pair_count": 154,
+      "timing_admitted": false
+    },
+    "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3": {
+      "dataset_result_count": 29,
+      "exact_source_profiles": [
+        "cpp-native192-first12-3452a998",
+        "cpp-native192-first12-39dc8c5d",
+        "cpp-native192-first12-9abdc80f",
+        "cpp-native192-first12-bf0a069f"
+      ],
+      "execution_host": "192.168.99.20",
+      "pair_count": 12,
+      "timing_admitted": false
+    },
+    "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2": {
+      "dataset_result_count": 5,
+      "exact_source_profiles": [
+        "cpp-native192-lzg-level5-fastfalse-41d0e8fc"
+      ],
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_admitted": false
+    },
+    "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1": {
+      "dataset_result_count": 6,
+      "exact_source_profiles": [
+        "cpp-native192-lzg-level5-fastfalse-00f34de8"
+      ],
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_admitted": false
+    },
+    "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3": {
+      "dataset_result_count": 15,
+      "exact_source_profiles": [
+        "cpp-native192-next5-39dc8c5d",
+        "cpp-native192-next5-9abdc80f",
+        "cpp-native192-next5-bf0a069f"
+      ],
+      "execution_host": "192.168.99.20",
+      "pair_count": 5,
+      "timing_admitted": false
+    }
+  },
+  "created_at": "2026-10-11T08:53:18.361574+00:00",
+  "dataset_count": 164,
+  "dropped_mixed_overall_count": 1708,
+  "files": {
+    "COVERAGE_SANITY.full_main166_dataset_results.jsonl.gz": {
+      "published_support_aware_rows": 25443,
+      "source_rows": 27151,
+      "source_sha256": "a9e0e5b790ca8aa320d8696cb4af54835725401b0450fa980765534dc92b3c74"
+    },
+    "legacy-dbp-medium-posts-independent-review.json": {
+      "sha256": "ec4095da7f99aebc07a4768cef15cba713a1b9e68a03d7ce41b23a9e7da3e5fd",
+      "source_sha256": "a200679cddddd96e7bd7488d499dcdeace7f098195e8ead502f70dc49af49043",
+      "status": "passed"
+    },
+    "legacy-dbp-medium-posts-timing-receipt.json": {
+      "sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+      "source_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+      "status": "passed"
+    },
+    "native86-main166-dataset-results.jsonl.gz": {
+      "published_support_aware_rows": 25443,
+      "sha256": "a9e0e5b790ca8aa320d8696cb4af54835725401b0450fa980765534dc92b3c74",
+      "source_rows": 27151
+    },
+    "native86-main166-independent-adjudication.json": {
+      "sha256": "ada06b5191e0edf92c862c68bb21562e7d46fbef014e71fb775a1b2b44dcf004",
+      "status": "partial_verification_blocked"
+    },
+    "native86-main166-pair-adjudication.jsonl": {
+      "rows": 920,
+      "sha256": "f55be6435dd7ff90dd04777f693299e73a2ef42fdf0e59f58eb3f1aa247e8aab"
+    },
+    "native86-main166-timing-proof.json": {
+      "sha256": "f0f502d348fa20f336911f960efb63da07ddfbe922327acc636554e36d62590c",
+      "status": "passed"
+    },
+    "native86-recovery-reconciliation.json": {
+      "accepted_unique_repair_pairs": 174,
+      "sha256": "39f05a3195a1aeb3ad23114322b40fa91a205e5f798e1ceb7598beb91ae7c0f2",
+      "status": "passed_with_one_omitted_problem_scheduled_for_separate_sidecar",
+      "unresolved_problem_pairs": 328
+    },
+    "native86-terminal-matrix.jsonl.gz": {
+      "rows": 13940,
+      "sha256": "1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9"
+    },
+    "native86-v9-current154-thin.jsonl.gz": {
+      "not_applicable_aggregates": 308,
+      "numeric_ok_aggregates": 5296,
+      "pairs": 154,
+      "sha256": "f538e84dd2b4fee3c1b0d68408095fc88714eafe3ac0e6a57d6dc674f39e47a0"
+    }
+  },
+  "host192_independently_verified_pair_count": 21,
+  "independent_adjudication": {
+    "pair_path": "native86-main166-pair-adjudication.jsonl",
+    "pair_sha256": "f55be6435dd7ff90dd04777f693299e73a2ef42fdf0e59f58eb3f1aa247e8aab",
+    "path": "native86-main166-independent-adjudication.json",
+    "sha256": "ada06b5191e0edf92c862c68bb21562e7d46fbef014e71fb775a1b2b44dcf004",
+    "status": "partial_verification_blocked",
+    "status_counts": {
+      "independently_adjudicated": 773,
+      "not_independently_adjudicated_missing_expected_gate_artifact": 147
+    }
+  },
+  "legacy_dbp_medium_posts_timing": {
+    "admitted_dataset_result_rows": 6,
+    "independent_review": {
+      "path": "legacy-dbp-medium-posts-independent-review.json",
+      "sha256": "ec4095da7f99aebc07a4768cef15cba713a1b9e68a03d7ce41b23a9e7da3e5fd",
+      "source_sha256": "a200679cddddd96e7bd7488d499dcdeace7f098195e8ead502f70dc49af49043"
+    },
+    "receipt": {
+      "path": "legacy-dbp-medium-posts-timing-receipt.json",
+      "sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+      "source_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324"
+    }
+  },
+  "main_dataset_result_count": 25443,
+  "main_numeric_aggregate_count": 290745,
+  "main_numeric_pair_count": 11164,
+  "main_timing_proof": {
+    "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+    "path": "native86-main166-timing-proof.json",
+    "schema": "paper164-old-main166-timing-provenance-readonly-v1",
+    "sha256": "f0f502d348fa20f336911f960efb63da07ddfbe922327acc636554e36d62590c",
+    "status": "passed"
+  },
+  "omitted_unresolved_pair_count": 1,
+  "pair_shape_counts": {
+    "all_na": 2274,
+    "all_numeric_ok": 9456,
+    "mixed_numeric_ok_and_na": 1708,
+    "terminal_problem_complete_with_failures": 431,
+    "terminal_problem_failed": 71
+  },
+  "profiles": {
+    "cpp-native166-main-458a218f": {
+      "aggregate_count": 290745,
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "comparison_profiles": [
+        "cpp-native166-main-458a218f"
+      ],
+      "dataset_result_count": 25443,
+      "execution_host": "166.111.68.166",
+      "pair_count": 11164,
+      "timing_profile_status": "timing_admitted_frozen_source_build_binary_boundary_bound"
+    },
+    "cpp-native166-recovery-3452a998": {
+      "aggregate_count": 2157,
+      "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 119,
+      "execution_host": "166.111.68.166",
+      "pair_count": 48,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-39dc8c5d": {
+      "aggregate_count": 1178,
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 141,
+      "execution_host": "166.111.68.166",
+      "pair_count": 57,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-458a218f": {
+      "aggregate_count": 642,
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 14,
+      "execution_host": "166.111.68.166",
+      "pair_count": 6,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-813812e1": {
+      "aggregate_count": 163,
+      "binary_sha256": "813812e15013991a809e82fafe710aae77e29c96fa5d2d9101d8323a9cd07e30",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "166.111.68.166",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-82297044": {
+      "aggregate_count": 39,
+      "binary_sha256": "822970447c25f2b5f18e2d750c2a9407b6a23f22cb9f59c40565273599e20fc0",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 2,
+      "execution_host": "166.111.68.166",
+      "pair_count": 1,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native166-recovery-9abdc80f": {
+      "aggregate_count": 1117,
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "comparison_profiles": [
+        "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 101,
+      "execution_host": "166.111.68.166",
+      "pair_count": 40,
+      "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
+    },
+    "cpp-native192-first12-3452a998": {
+      "aggregate_count": 493,
+      "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 5,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-first12-39dc8c5d": {
+      "aggregate_count": 568,
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 10,
+      "execution_host": "192.168.99.20",
+      "pair_count": 4,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-first12-9abdc80f": {
+      "aggregate_count": 148,
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 11,
+      "execution_host": "192.168.99.20",
+      "pair_count": 5,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-first12-bf0a069f": {
+      "aggregate_count": 66,
+      "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+      "comparison_profiles": [
+        "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 3,
+      "execution_host": "192.168.99.20",
+      "pair_count": 1,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-lzg-level5-fastfalse-00f34de8": {
+      "aggregate_count": 140,
+      "binary_sha256": "00f34de8d145e114d19bc592935fe33b241394692c4a28fd9b8597d809dd3351",
+      "comparison_profiles": [
+        "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-lzg-level5-fastfalse-41d0e8fc": {
+      "aggregate_count": 56,
+      "binary_sha256": "41d0e8fc01f94ffa9d2f07796f7fc1bc45a194491535ec927ef627d663f62b08",
+      "comparison_profiles": [
+        "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2"
+      ],
+      "dataset_result_count": 5,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-next5-39dc8c5d": {
+      "aggregate_count": 118,
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "comparison_profiles": [
+        "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-next5-9abdc80f": {
+      "aggregate_count": 44,
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "comparison_profiles": [
+        "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 3,
+      "execution_host": "192.168.99.20",
+      "pair_count": 1,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    },
+    "cpp-native192-next5-bf0a069f": {
+      "aggregate_count": 118,
+      "binary_sha256": "bf0a069fc311f2eff2e0cfbb7d389b296c7582b03ed3689004fc397dd837374f",
+      "comparison_profiles": [
+        "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 6,
+      "execution_host": "192.168.99.20",
+      "pair_count": 2,
+      "timing_profile_status": "timing_diagnostic_external_host_pair_verified_without_source_build_boundary_proof"
+    }
+  },
+  "schema": "site-native86-full-terminal-coverage-v2",
+  "status": "passed",
+  "terminal_pair_count": 13940,
+  "unresolved_problem_pair_count": 328,
+  "v9_numeric_ok_aggregate_count": 5296,
+  "v9_recovered_pair_count": 154
+}

native86-main166-dataset-results.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9e0e5b790ca8aa320d8696cb4af54835725401b0450fa980765534dc92b3c74
+size 3393199

native86-main166-independent-adjudication.json

@@ -0,0 +1,99 @@
+{
+  "aggregate_count": 23794,
+  "blocking_reason": "147 recovery-source pairs reference aggregate metadata indexes/catalogs that are absent from the local bundle; exact expected gate ID coverage cannot be independently recomputed.",
+  "captured_at": "2026-10-11T05:55:41.544984+00:00",
+  "checks_per_pair": [
+    "inventory receipt SHA",
+    "receipt identity and successful process status",
+    "result and cold SHA",
+    "result and cold status exactly ok",
+    "unique and equal result/cold aggregate ID sets",
+    "cold frame SHA and aggregate metadata equality",
+    "fresh-process cold rows",
+    "gate aggregate count and source SHA fields",
+    "strict admission gate proof or bundled expected aggregate index"
+  ],
+  "dataset_provenance": {
+    "dataset_count": 164,
+    "incomplete_dataset_ids": [
+      "bitcoin_price_timeseries",
+      "crypto_data",
+      "electricity_production",
+      "reg_forecasting_v2",
+      "salesforecastingwomartstore",
+      "spx",
+      "timeseries-1m-QQQ-10y",
+      "timeseries-finance-ETF",
+      "timeseries_1mn_sp500",
+      "timeseries_1mn_stocks",
+      "timeseries_finance_etf_missing",
+      "us_stock_financial_ratios",
+      "weather_data_bavaria",
+      "xauusd",
+      "xauusd_1m"
+    ],
+    "origin_class_counts": {
+      "derived_from_real": 75,
+      "real_measured": 89
+    },
+    "provenance_status_counts": {
+      "incomplete": 15,
+      "source_supported": 149
+    },
+    "publication_qualifier": "15 datasets retain provenance_status=incomplete even though all 164 are real_measured or derived_from_real."
+  },
+  "decision": "do_not_claim_all_920_independently_verified",
+  "execution_host": "166.111.68.166",
+  "inputs": {
+    "dataset_catalog": {
+      "path": "source-checkout/analysis_outputs/site_native192_bundle_20261011/review_v3/dataset-catalog.json",
+      "sha256": "a060e36c1023098c9aed0e262831e11b70dff53a4db4e7de26b4f812e6087538"
+    },
+    "inventory": {
+      "path": "source-checkout/analysis_outputs/site_native192_bundle_20261011/NATIVE166_SOURCE_INVENTORY.json",
+      "sha256": "505507f03fed557fc864f8aaa6dd754889965cd81284986e117c9e85580ed4d8"
+    },
+    "site_data": {
+      "path": "source-checkout/analysis_outputs/site_native192_bundle_20261011/review_v3/data.json",
+      "sha256": "7cd07edf98658b7e394bf6da230b9d6dafb1df6cf3153e763b0fae74c740e76e"
+    },
+    "site_review_receipt": {
+      "path": "source-checkout/analysis_outputs/site_native192_bundle_20261011/SITE_REVIEW_RECEIPT.json",
+      "sha256": "2c952cb3836d00821f3b1815ec99430d9a7c0e50c41ac652dd1e8efdfeecaf0c"
+    },
+    "verifier": {
+      "path": "source-checkout/analysis_outputs/site_native192_bundle_20261011/independent_review/native166_adjudication/verify_native166.py",
+      "sha256": "df6510399edc7ef05ac5e918d77b6263cb91f93c2146df710da2bc3b62a8c900"
+    }
+  },
+  "pair_adjudication": {
+    "path": "native86-main166-pair-adjudication.jsonl",
+    "rows": 920,
+    "sha256": "f55be6435dd7ff90dd04777f693299e73a2ef42fdf0e59f58eb3f1aa247e8aab",
+    "source_sha256": "e34785294f4cdf27b19c1bfe8f71651e88457f110801560b20747de304f4e817"
+  },
+  "pair_count": 920,
+  "reviewer": {
+    "context": "fresh_context_subagent",
+    "independence_note": "Independent evidence pass; same OpenAI model family as coordinating review, so model-diversity independence is provisional.",
+    "model": "gpt-5.6-sol",
+    "reasoning_effort": "xhigh"
+  },
+  "schema": "paper164-native166-independent-adjudication-summary-v1",
+  "source_kind_aggregate_counts": {
+    "fresh50k_crush": 74,
+    "main_strict_admission": 20927,
+    "v9_recovered": 2793
+  },
+  "source_kind_pair_counts": {
+    "fresh50k_crush": 1,
+    "main_strict_admission": 773,
+    "v9_recovered": 146
+  },
+  "source_receipt_sha256": "729a0d25120d8c714ef245e0a91214c8fa96cf244f6e78011ea43021cdef731b",
+  "status": "partial_verification_blocked",
+  "status_counts": {
+    "independently_adjudicated": 773,
+    "not_independently_adjudicated_missing_expected_gate_artifact": 147
+  }
+}

native86-main166-timing-proof.json

@@ -0,0 +1,251 @@
+{
+  "admission_decision": {
+    "boundaries": "Do not pool with host192 or repaired adapter binaries/profiles. Compare only exact eligible aggregate-id support cohorts. Source/compound file I/O is excluded by the declared profile.",
+    "profile_id": "cpp-native166-baseline86-fixed-profiles-20260919-v3-binary-458a218f",
+    "reason": "The build-smoke receipt binds baseline source hashes to the exact binary hash; current source hashes match it; every main receipt binds that binary and timing profile; result SHAs bind the declared timing scope; inspected source times full encode/decode and adds compound-prefix overhead.",
+    "status": "timing_admitted_within_exact_host_binary_profile_and_support_cohort"
+  },
+  "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+  "binary_sha_matches_build_smoke": true,
+  "build_smoke_embedded_receipt": {
+    "baseline_source": "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1",
+    "baseline_source_sha256": {
+      "CMakeLists.txt": "ee38a603541e123963488c8a0187a31bdf30b4e636471ad9d6147f3cf38d54ca",
+      "README.md": "0d9ecacfb055e2b4097e66954570250994af6d4daf4cbb9b7e7e34b06201cf28",
+      "baseline.cpp": "313d635986d0ba25ca3f811dc891fbb6a3e22bdb03e0c0d033f1c2ba9b3b61f0",
+      "baseline.hpp": "68c752deea056d8741778536f932bc616120ca2dbb2993072ac019705be4d0de"
+    },
+    "binary": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/paper172_native_baseline86_batch",
+    "binary_file": "ELF 64-bit LSB pie executable, x86-64, version 1 (GNU/Linux), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=776a07784a557318a07726f8aaac7d34a6710ce4, for GNU/Linux 3.2.0, not stripped",
+    "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+    "catalog_labels": 86,
+    "cold_failed_rows": 0,
+    "cold_receipt_rows": 276,
+    "cold_receipt_schema": "paper172-native-baseline86-cold-verification-v1",
+    "cold_receipts_sha256": "495bbcd25816c9379c17d15c981e19d0ca5fd9c6d9251af94a80e87e0c534df6",
+    "cold_verified_dtypes": [
+      "float32",
+      "float64",
+      "int64"
+    ],
+    "entity_reset": "one NGF1 child frame per contiguous entity segment",
+    "fixture_receipt_sha256": "ced8c5961d01ee0cec549abd558f67ea573d83a5ff6992daea1f994a9e2d2c72",
+    "host": "server",
+    "input_schema": "paper172-typed-entity-segments-v1",
+    "inventory_sha256": "f990aba57aae9835702f3fdf06eefe0c7e8f56225be4f895633856e39db9b393",
+    "json_include": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/control/vendor_include",
+    "json_include_file_count": 46,
+    "json_include_tree_sha256": "a3cdebea975c890a709a7c8155de4e8a1b00d29fa697719334848ad66983aa04",
+    "profile_version": "baseline86-fixed-profiles-20260919-v3",
+    "result_schema": "paper172-native-baseline86-aggregate-v1",
+    "result_unit": "aggregate_id x method",
+    "results_sha256": "9a866e95b317285db2d24feafa12b3ae07e25bbedfd5cd164dd4b55749a17218",
+    "schema": "paper172-native-baseline86-build-smoke-receipt-v1",
+    "smoke_failed_rows": 7,
+    "smoke_failure_records": [
+      {
+        "aggregate_id": "smoke/float32",
+        "dtype": "float32",
+        "method": "Tornado",
+        "reason": "Tornado: encode failed"
+      },
+      {
+        "aggregate_id": "smoke/float64",
+        "dtype": "float64",
+        "method": "Sprintz",
+        "reason": "invalid Sprintz floating Gorilla tail"
+      },
+      {
+        "aggregate_id": "smoke/float64",
+        "dtype": "float64",
+        "method": "Camel",
+        "reason": "Camel exact action does not support non-finite values"
+      },
+      {
+        "aggregate_id": "smoke/float64",
+        "dtype": "float64",
+        "method": "Elf",
+        "reason": "Elf64 NaN conflicts with the codec EOS marker; filter NaNs before encoding"
+      },
+      {
+        "aggregate_id": "smoke/float64",
+        "dtype": "float64",
+        "method": "Elf+",
+        "reason": "Elf64 NaN conflicts with the codec EOS marker; filter NaNs before encoding"
+      },
+      {
+        "aggregate_id": "smoke/float64",
+        "dtype": "float64",
+        "method": "Tornado",
+        "reason": "Tornado: encode failed"
+      },
+      {
+        "aggregate_id": "smoke/int64",
+        "dtype": "int64",
+        "method": "Tornado",
+        "reason": "Tornado: encode failed"
+      }
+    ],
+    "smoke_ok_or_na_rows": 276,
+    "smoke_result_rows": 344,
+    "smoke_unsupported_rows": 61,
+    "status": "ok",
+    "timing_profile": {
+      "repeats": 3,
+      "warmups": 1
+    }
+  },
+  "build_smoke_status": {
+    "ended_at_utc": "2026-10-07T15:10:46Z",
+    "exit_code": 0,
+    "log": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/logs/build_smoke_20261007T151042Z.log",
+    "schema": "paper172-runtime-build-smoke-status-v1",
+    "started_at_utc": "2026-10-07T15:10:42Z",
+    "status": "ok"
+  },
+  "current_baseline_source_matches_build_smoke_hashes": true,
+  "current_baseline_source_sha256": {
+    "CMakeLists.txt": "ee38a603541e123963488c8a0187a31bdf30b4e636471ad9d6147f3cf38d54ca",
+    "README.md": "0d9ecacfb055e2b4097e66954570250994af6d4daf4cbb9b7e7e34b06201cf28",
+    "baseline.cpp": "313d635986d0ba25ca3f811dc891fbb6a3e22bdb03e0c0d033f1c2ba9b3b61f0",
+    "baseline.hpp": "68c752deea056d8741778536f932bc616120ca2dbb2993072ac019705be4d0de"
+  },
+  "files": {
+    "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1/CMakeLists.txt": {
+      "bytes": 15664,
+      "mtime_ns": 1790347072254818058,
+      "path": "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1/CMakeLists.txt",
+      "sha256": "ee38a603541e123963488c8a0187a31bdf30b4e636471ad9d6147f3cf38d54ca"
+    },
+    "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1/baseline.cpp": {
+      "bytes": 40296,
+      "mtime_ns": 1790347072254818058,
+      "path": "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1/baseline.cpp",
+      "sha256": "313d635986d0ba25ca3f811dc891fbb6a3e22bdb03e0c0d033f1c2ba9b3b61f0"
+    },
+    "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1/baseline.hpp": {
+      "bytes": 2394,
+      "mtime_ns": 1790347072254818058,
+      "path": "/data/user/new_ai_compress/operator_sweep/native_v713_v621_stop_zstd_same_elf_linux166_qualification_20260926_v1/bundle/web_compression/cpp/native_baseline86_v1/baseline.hpp",
+      "sha256": "68c752deea056d8741778536f932bc616120ca2dbb2993072ac019705be4d0de"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/BUILD_SMOKE_STATUS.json": {
+      "bytes": 300,
+      "mtime_ns": 1791385846243365993,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/BUILD_SMOKE_STATUS.json",
+      "sha256": "64ce223cc1281075ee521607c949339da24bec72bf6a3ab3e3204308cfd3ca9d"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeCache.txt": {
+      "bytes": 31500,
+      "mtime_ns": 1791385618581599022,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeCache.txt",
+      "sha256": "525787a339b8d80b07b465163b54713a102ffe6449aaea51ddd02c038f16d6f2"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/build.make": {
+      "bytes": 9006,
+      "mtime_ns": 1791385426940111618,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/build.make",
+      "sha256": "22208c4f0d6d494a64284c6d7d0b56349a7ec421d7e8d92950ff46e1eaad82cf"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/flags.make": {
+      "bytes": 5354,
+      "mtime_ns": 1791385618605599208,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/flags.make",
+      "sha256": "3543d42b325c619eab2ac172c9332b4e90f0432ecda42c58bdc8536d94399fb5"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/link.txt": {
+      "bytes": 1429,
+      "mtime_ns": 1791385426940111618,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/link.txt",
+      "sha256": "b4a9be571b3d26cc779e98468d3876b3cacb07a4efb2e1545ba12680f476aa5a"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/native_baseline86_batch.cpp.o": {
+      "bytes": 563072,
+      "mtime_ns": 1791385655801887903,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/CMakeFiles/paper172_native_baseline86_batch.dir/native_baseline86_batch.cpp.o",
+      "sha256": "ad113e326468ce61e88240b6e10038846883b19dddd7aa71e1e8e2a3b3e154b0"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/baseline86/libnative_baseline86_v1.a": {
+      "bytes": 589848,
+      "mtime_ns": 1791385647993827302,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/baseline86/libnative_baseline86_v1.a",
+      "sha256": "6ec5521d04327d646a527df4090259c5b6da57ee2e56592549788d5ce49c30e9"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/paper172_native_baseline86_batch": {
+      "bytes": 6457104,
+      "mtime_ns": 1791385656065889951,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/build/baseline86_batch_release/paper172_native_baseline86_batch",
+      "sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/logs/build_smoke_20261007T151042Z.log": {
+      "bytes": 5318,
+      "mtime_ns": 1791385846211365744,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/logs/build_smoke_20261007T151042Z.log",
+      "sha256": "679683214a84001b3e6cbfb50c64a6d0c8811f9a143746d556cb780836fb5678"
+    },
+    "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/source/baseline86_batch/native_baseline86_batch.cpp": {
+      "bytes": 28094,
+      "mtime_ns": 1791384795000000000,
+      "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/source/baseline86_batch/native_baseline86_batch.cpp",
+      "sha256": "308cbd8fd76b44a99687fb4dfc5e873369da3ed87eac4b731ccbb245d5c93211"
+    }
+  },
+  "host": "166.111.68.166",
+  "result_evidence": {
+    "invalid_timing_value_rows": 0,
+    "missing_timing_value_rows": 0,
+    "numeric_ok_aggregates": 290745,
+    "ok_receipts": 13438,
+    "receipt_binary_sha256_counts": {
+      "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664": 13940
+    },
+    "receipt_controller_sha256_counts": {
+      "8d2aabbc83dda0716db71507807d30187f8f67aaa9fc8a9f4a1e0819a7620250": 397,
+      "a78e3b47d42d34c10b001f330f9c6762a5354452fa7189ef15346e195eff3b7e": 1068,
+      "f3d7a393c139c80a77dc965841e7735b3abd6817beffcd1c197bd7d2be4d0d2e": 12475
+    },
+    "receipt_timing_profile_counts": {
+      "{\"cpu\":10,\"repeats\":3,\"threads\":1,\"warmups\":1}": 687,
+      "{\"cpu\":11,\"repeats\":3,\"threads\":1,\"warmups\":1}": 1003,
+      "{\"cpu\":12,\"repeats\":3,\"threads\":1,\"warmups\":1}": 1112,
+      "{\"cpu\":13,\"repeats\":3,\"threads\":1,\"warmups\":1}": 522,
+      "{\"cpu\":14,\"repeats\":3,\"threads\":1,\"warmups\":1}": 347,
+      "{\"cpu\":15,\"repeats\":3,\"threads\":1,\"warmups\":1}": 177,
+      "{\"cpu\":16,\"repeats\":3,\"threads\":1,\"warmups\":1}": 1130,
+      "{\"cpu\":17,\"repeats\":3,\"threads\":1,\"warmups\":1}": 300,
+      "{\"cpu\":18,\"repeats\":3,\"threads\":1,\"warmups\":1}": 145,
+      "{\"cpu\":19,\"repeats\":3,\"threads\":1,\"warmups\":1}": 537,
+      "{\"cpu\":20,\"repeats\":3,\"threads\":1,\"warmups\":1}": 348,
+      "{\"cpu\":21,\"repeats\":3,\"threads\":1,\"warmups\":1}": 153,
+      "{\"cpu\":22,\"repeats\":3,\"threads\":1,\"warmups\":1}": 362,
+      "{\"cpu\":23,\"repeats\":3,\"threads\":1,\"warmups\":1}": 217,
+      "{\"cpu\":24,\"repeats\":3,\"threads\":1,\"warmups\":1}": 1085,
+      "{\"cpu\":25,\"repeats\":3,\"threads\":1,\"warmups\":1}": 625,
+      "{\"cpu\":26,\"repeats\":3,\"threads\":1,\"warmups\":1}": 867,
+      "{\"cpu\":27,\"repeats\":3,\"threads\":1,\"warmups\":1}": 775,
+      "{\"cpu\":28,\"repeats\":3,\"threads\":1,\"warmups\":1}": 327,
+      "{\"cpu\":29,\"repeats\":3,\"threads\":1,\"warmups\":1}": 1069,
+      "{\"cpu\":30,\"repeats\":3,\"threads\":1,\"warmups\":1}": 161,
+      "{\"cpu\":31,\"repeats\":3,\"threads\":1,\"warmups\":1}": 785,
+      "{\"cpu\":8,\"repeats\":3,\"threads\":1,\"warmups\":1}": 277,
+      "{\"cpu\":9,\"repeats\":3,\"threads\":1,\"warmups\":1}": 929
+    },
+    "result_profile_version_counts": {
+      "baseline86-fixed-profiles-20260919-v3": 290745
+    },
+    "result_timing_scope_counts": {
+      "resident C++ per-entity NGF1 encode/decode plus in-memory compound length-prefix construction/parsing; source and compound file I/O excluded": 290745
+    }
+  },
+  "schema": "paper164-old-main166-timing-provenance-readonly-v1",
+  "source_semantics": {
+    "baseline_measure_times_complete_decode_call": true,
+    "baseline_measure_times_complete_encode_call": true,
+    "binary_embeds_expected_timing_scope": true,
+    "binary_embeds_profile_version": true,
+    "wrapper_adds_compound_prefix_decode_overhead": true,
+    "wrapper_adds_compound_prefix_encode_overhead": true,
+    "wrapper_emits_expected_timing_scope": true
+  },
+  "status": "passed"
+}

native86-recovery-reconciliation.json

@@ -0,0 +1,2476 @@
+{
+  "accepted_pair_identities": [
+    {
+      "dataset_id": "ETDataset-ett",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "METR-LA",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "PEMS-BAY",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "PEMS-BAY",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "SpatialEpiBench",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "SpatialEpiBench",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "africa_senegal_mauritania_crops_spi",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "ast_spacemobile_fleet_data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "auto_production_sf",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "bitcoin",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "car_parts",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "coastal_t_s",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "coastal_t_s",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "coastal_t_s",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "commodity_import",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "commodity_production",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "commodity_production",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "commodity_production",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "covid_deaths-monash",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "dmi-aarhus-weather-data",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "dmi-aarhus-weather-data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "Lzlib"
+    },
+    {
+      "dataset_id": "epf_electricity_price",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "forex_factory_calendar",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "fulus_lyd_rates_2025",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "github_top_projects",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "github_top_projects",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "global_influenza",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "global_influenza",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "global_price",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "global_price",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "globalstar_fleet_data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Lzlib"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "hospital-monash",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "hourly-stock-data-2023",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "hourly_electricity_demand_brazil",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "housing_inventory",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "indian_stock_hourly_2017_2021",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "job_claims",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "jolts",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kuiper_fleet_data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "magseven_ml_ready_high_frequency_anomaly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "national_illness",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "niederschlag_station_4091_bavaria_germany",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "nn5_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "openelectricity_nem",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "phenology_normal_hawaii",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "port_activity",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "port_activity",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "reg_forecasting_v2",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "saugeenday-monash",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "scaphandre_cpu_usage",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "sg_carpark",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "sg_pm25",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "sg_weather",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "solar_10_minutes",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "solar_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "solusdt_enhanced_180",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "substorm_onsets",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries-1m-QQQ-10y",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "timeseries_1mn_sp500",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_quarterly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_quarterly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_yearly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "traffic",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "traqq_weekly_activity",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "trending_stocks_yahoo_finance",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "trending_stocks_yahoo_finance",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "uk_electricity_generation_mix_2019_2026",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "us_labor",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "us_labor",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "us_stock_financial_ratios",
+      "method": "Bzip3"
+    },
+    {
+      "dataset_id": "us_stock_financial_ratios",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "us_term_structure",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "vehicle_supply",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "vehicle_trips",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "water_quality_darwin",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "water_quality_darwin",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "weather_data_NC",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Tornado"
+    }
+  ],
+  "admission": {
+    "host192_rate_and_bytes": "independently verified strict pairs",
+    "host192_timing": "diagnostic unless its exact variant proof is attached",
+    "unresolved": "current327 and omitted Shrinker are not results",
+    "v9_rate_and_bytes": "receipt/result/cold SHA-bound; all 154 have at least one numeric ok aggregate",
+    "v9_timing": "diagnostic per variant until independent source/build/timing-boundary proof"
+  },
+  "counts": {
+    "accepted_unique_repair_pairs": 174,
+    "current327_backfill_pairs": 327,
+    "current_numeric_pairs_after_accepted_overlay": 11338,
+    "current_unresolved_pairs": 328,
+    "host192_strict_pairs": 21,
+    "matrix_pairs": 13940,
+    "omitted_unresolved_pairs": 1,
+    "original_active_problem_pairs": 502,
+    "original_main_all_na_pairs": 2274,
+    "original_main_numeric_pairs": 11164,
+    "v9_aggregate_rows": 5604,
+    "v9_current_recovered_pairs": 154,
+    "v9_host192_overlap_pairs": 1,
+    "v9_na_aggregate_rows": 308,
+    "v9_new_since_stale_inventory": 8,
+    "v9_numeric_ok_aggregate_rows": 5296,
+    "v9_stale_inventory_pairs": 146
+  },
+  "current327_pair_identities": [
+    {
+      "dataset_id": "Air-Quality",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Bar-Crawl",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Bar-Crawl",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "Bar-Crawl",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "Bar-Crawl",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "Bird-migration",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Bird-migration",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "Bird-migration",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "Comments",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Comments",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "Comments",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "Comments",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "ETDataset-ett",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "ETDataset-ett",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "IGlocations2",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "IGlocations2",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "IGlocations2",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "IGlocations2",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "METR-LA",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "METR-LA",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "Metro-Traffic",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Metro-Traffic",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "NYC_Yellow_Taxi_Trip",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "NYC_Yellow_Taxi_Trip",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "NYC_Yellow_Taxi_Trip",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "PEMS-BAY",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "PEMS-BAY",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "PEMS-BAY",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "RealEstate1",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "RealEstate1",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "RealEstate1",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "RealEstate2",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "RealEstate2",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "RealEstate2",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "RealEstate2",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "RealEstate2",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "Romance",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Romance",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "Romance",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "Romance",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "Romance",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "SpatialEpiBench",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "SpatialEpiBench",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "Telco",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Telco",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "Telco",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "Telco",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "Telco",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "Telco",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "TrainsUK2",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "TrainsUK2",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "TrainsUK2",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "Uberlandia",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Uberlandia",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "Uberlandia",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "Uberlandia",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "Uberlandia",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "Uberlandia",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "YaleLanguages",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "YaleLanguages",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "YaleLanguages",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "YaleLanguages",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "africa_senegal_mauritania_crops_spi",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "australia_solar",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "australian_electricity_demand",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "azure2019_u",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "bitcoin",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "bitcoin",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "car_parts",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "car_parts",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "coastal_t_s",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "coastal_t_s",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "commodity_production",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "crypto_data",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "crypto_data",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "crypto_data",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "crypto_data",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "crypto_data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "deep-space-probes",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "deep-space-probes",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "deep-space-probes",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "deep-space-probes",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "deep-space-probes",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "dmi-aarhus-weather-data",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "dst-index",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "dst-index",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ecdc_covid",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "ecdc_covid",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ecdc_covid",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "electricity_demand",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "electricity_production",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "enedis-with-holidays",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "enedis-with-holidays",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "enedis-with-holidays",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "eweld_load",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "eweld_load",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "eweld_load",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "faang_engineered_time_series_features_2013_2025",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "forex_factory_calendar",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "forex_factory_calendar",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "fred_md",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "fred_md",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "fred_md",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "github_top_projects",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "global_influenza",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "hourly-stock-data-2023",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "hourly-stock-data-2023",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "indian_stock_hourly_2017_2021",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "indian_stock_hourly_2017_2021",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "medium_posts",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "metropt_3",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "multi_model_trading_data",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "multi_model_trading_data",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "nasa_maven_kp_insitu",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "nasa_maven_kp_insitu",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "nasa_maven_kp_insitu",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ne_china_wind",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "nifty50_market_regime",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "openelectricity_nem",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "openelectricity_nem",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "port_activity",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "rating",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "rating",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "rating",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "reg_forecasting_v2",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "reg_forecasting_v2",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "saugeenday-monash",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "saugeenday-monash",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "sg_carpark",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "sg_carpark",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "sg_pm25",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "sg_pm25",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "solar_10_minutes",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "solar_10_minutes",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "solusdt_enhanced_180",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "solusdt_enhanced_180",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "spx",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "substorm_onsets",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "substorm_onsets",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries-1m-QQQ-10y",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "timeseries-1m-QQQ-10y",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries_1mn_sp500",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "timeseries_1mn_sp500",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "tourism_quarterly",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "traffic",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "traffic",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "trending_stocks_yahoo_finance",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "uk_electricity_generation_mix_2019_2026",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "uk_electricity_generation_mix_2019_2026",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "us_births-monash",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "us_labor",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "us_stock_financial_ratios",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "vehicle_trips",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "water_quality_darwin",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "weather_data_NC",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "weather_data_NC",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "wids2023_competition_weather_forecasting",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "wind_4_seconds",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "wind_4_seconds",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "wind_4_seconds",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "wind_4_seconds",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "wind_4_seconds",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "wordle_mcm_dataset",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "wui_global",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "wui_global",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "wui_global",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "xauusd",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "xauusd",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "xauusd",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "xauusd",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "xauusd_1m",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "xauusd_1m",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "xinyi_public_gym",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "xinyi_public_gym",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "yongchun_public_gym",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "yongchun_public_gym",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "yongchun_public_gym",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Shrinker"
+    }
+  ],
+  "equations": {
+    "accepted_unique": "154 + 21 - 1 = 174",
+    "matrix_partition": "13940 = 11338 numeric + 2274 N/A + 328 unresolved",
+    "problem_partition": "502 = 174 accepted + 327 current backfill + 1 omitted Shrinker",
+    "stale_inventory_gap": "154 current V9 - 146 stale V9 = 8 newly recovered"
+  },
+  "identity": "dataset_id + method label; method_id retained in source records",
+  "omitted_unresolved": [
+    {
+      "baseline_receipt": {
+        "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/formal_native86/by_dataset/wids2023_competition_weather_forecasting/receipts/7212325e8079e5c3.json",
+        "schema": "paper172-native86-method-dataset-receipt-v1",
+        "sha256": "ab4a95198ed63a154030df855470cb8e6c4bda4b746aeb4294edfb85335063d5",
+        "status": "complete_with_failures"
+      },
+      "cold": {
+        "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/formal_native86/by_dataset/wids2023_competition_weather_forecasting/cold/7212325e8079e5c3.jsonl",
+        "rows": 485,
+        "sha256": "9ef1899b4e4fbf49d6fd6b9c6c845e6849ac122aa4d4e574e4e2311043ab3ad8",
+        "status_counts": {
+          "ok": 485
+        }
+      },
+      "current327_disposition": "absent; must run in a separate new root",
+      "dataset_id": "wids2023_competition_weather_forecasting",
+      "failed_aggregate_ids": [
+        "wids2023_competition_weather_forecasting|value|c0006",
+        "wids2023_competition_weather_forecasting|value|c0249"
+      ],
+      "failure_classes": [
+        "RECONSTRUCTION_MISMATCH"
+      ],
+      "failure_reasons": [
+        "restored root SHA-256 mismatch"
+      ],
+      "identity": {
+        "catalog_sha256": "12b5df6bbb51168b5a5dc127e7924abae63ea1ef270de5443f20ace03e5dd95f",
+        "input_integrity_segment_descriptor_sha256_chain": "0c8f27323d59305825888e26f4e4b59c9993f95c40793a815dd7b3f12553b77f",
+        "input_integrity_typed_file_sha256_chain": "742f0deb983bf6247d3836f5fd9b3815471e29cb212497b2f80f7779515d1ee0",
+        "manifest_sha256": "28798242c37ad0892e6663fda33f3267d74810091aa396aa73b2db91128ab0ce",
+        "ready_sha256": "868674b0a121a7e6d0d112ed9462aacf8c7ce4258f93df0b499808334ff5da34",
+        "source_preparation_contract_sha256": "bb54b64b46301740349443b4d027ba15ce53053f9b6fb6863b2a7aea590e777e"
+      },
+      "launch_conditions": {
+        "exact_baseline_receipt_rehash_required": true,
+        "exact_result_cold_and_process_log_rehash_required": true,
+        "fresh_isolated_attempt_ledger_required": true,
+        "no_original_claim_may_be_ignored": true,
+        "review_receipt_bound_to_this_manifest_sha256": true,
+        "shared_cpu_lock_and_temporary_reservation_required": true
+      },
+      "method": "Shrinker",
+      "method_id": "7212325e8079e5c3",
+      "resolved_by_later_receipt": false,
+      "result": {
+        "path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/formal_native86/by_dataset/wids2023_competition_weather_forecasting/results/7212325e8079e5c3.jsonl",
+        "rows": 487,
+        "sha256": "ead5f3682f02335fd0bf69622c4a2f870702a8e837f81c3cef338eacd90c2433",
+        "status_counts": {
+          "failed": 2,
+          "ok": 485
+        }
+      },
+      "selection_key_hex": "77696473323032335f636f6d7065746974696f6e5f776561746865725f666f726563617374696e670037323132333235653830373965356333",
+      "v9_disposition": "approved seventh-phase supplement was not dispatched"
+    }
+  ],
+  "overlap": [
+    {
+      "dataset_id": "weather_data_bavaria",
+      "method": "LZG"
+    }
+  ],
+  "schema": "paper164-recovery-key-reconciliation-v1",
+  "source_artifacts": {
+    "host192_strict21": {
+      "path": "source-checkout/analysis_outputs/paper164_performance_refresh_20261011/feeds/host192_strict_pairs.csv",
+      "sha256": "18458f2d62cdf7966a928bf05353ecc906892e22dc582e52e09731158412f583"
+    },
+    "main_terminal": {
+      "path": "source-checkout/analysis_outputs/paper164_performance_refresh_20261011/COVERAGE_SANITY.full_main166_terminal_pairs.jsonl.gz",
+      "sha256": "1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9"
+    },
+    "remote_key_evidence": {
+      "path": "source-checkout/analysis_outputs/paper164_performance_refresh_20261011/COVERAGE_SANITY.recovery_remote_key_evidence.json",
+      "sha256": "02df77fa3671ce53a67352d3b4af50b1e0dc5bb1185c97f1ec33ad0dc177a746"
+    },
+    "undispatched_shrinker_supplement": {
+      "path": "source-checkout/analysis_outputs/v9_runner_status_compat_20261010/remote_inputs/RETRY_MANIFEST_ORIGINAL_SUPPLEMENT_V1_WEBSITE164_FILTERED_METHOD85_V9_EXECUTION356_IDLE_V2_85e6e3b6b7ef84458090605c023efab02741960598be7d2cfe910cc28f24a8fb.json",
+      "sha256": "85e6e3b6b7ef84458090605c023efab02741960598be7d2cfe910cc28f24a8fb"
+    },
+    "v9_current154_thin": {
+      "path": "source-checkout/analysis_outputs/paper164_performance_refresh_20261011/COVERAGE_SANITY.v9_current154_thin.jsonl.gz",
+      "sha256": "f538e84dd2b4fee3c1b0d68408095fc88714eafe3ac0e6a57d6dc674f39e47a0"
+    },
+    "v9_stale146": {
+      "path": "source-checkout/analysis_outputs/paper164_performance_refresh_20261011/COVERAGE_SANITY.v9_overlay166.json",
+      "sha256": "78f45e11ebf8f77fdbf9164583710ede4bfc9824c90ceb3512cd67fcc290473c"
+    }
+  },
+  "source_receipt_sha256": "e3660b8dd40a3f124d54c53e4814ee20d91a711c1ea323b53bb6675d81612498",
+  "status": "passed_with_one_omitted_problem_scheduled_for_separate_sidecar",
+  "v9_new_since_stale_inventory": [
+    {
+      "all_aggregate_ids_sha256": "d497478804b3b649930470bdc28af6753e768d8e6ef12ff9380ef641ca8bf4d7",
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/by_dataset/jovian_lightning/cold/30405ccbe4d82992.jsonl",
+      "cold_rows": 69,
+      "cold_sha256": "a339d41be64bd0fcc2311b5c5337826e4fa55dca87c64562fc29fef61d859f25",
+      "cold_status_counts": {
+        "ok": 69
+      },
+      "dataset_id": "jovian_lightning",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/full/blocks.jsonl",
+        "catalog_sha256": "fa530831a22eadb3ea5eaf1ae7476428f511828ece554e2e0e88f95c88a53f01",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/input_integrity/jovian_lightning.json",
+        "input_integrity_audit_sha256": "0adc7d2fc7bd18333c780a9d2d8a4ceaf2d8744f42b927becdbdd788126270b3",
+        "input_integrity_segment_descriptor_sha256_chain": "09ab4615e6316ea10216a0ae562166c3ad02237365e474b958dbedec287e4069",
+        "input_integrity_typed_file_sha256_chain": "5c13312301ee850edcc8400046b3482183b3ff90e286677b7f3b65841c728ee8",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/dataset_manifest.json",
+        "manifest_sha256": "45fe6083f19b1b0410437b462c16c4145d6ad95be2e6749cb5081b5377a6dc5f",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/READY.json",
+        "ready_sha256": "e9c1390e477234f3520071d501b77cc99353847f966a3fa99595704b2982937a"
+      },
+      "method": "LZJB",
+      "method_id": "30405ccbe4d82992",
+      "numeric_ok_aggregate_count": 68,
+      "numeric_ok_aggregate_ids_sha256": "6983f0e7cbed77f744e8ba7019e8786e9ad2d3ddd4d0f2eb23bfbbc729d51918",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/by_dataset/jovian_lightning/receipts/30405ccbe4d82992.json",
+      "receipt_sha256": "0a87a9828f9bc3499596e2b900a4605ca5e1597c7a326f9e8fef7989a4f0f479",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/by_dataset/jovian_lightning/results/30405ccbe4d82992.jsonl",
+      "result_rows": 69,
+      "result_sha256": "05a4c9652a006dfbcb4625d26f211d4f57aaf0ace4ecbd736ea2ec395215d94f",
+      "result_status_counts": {
+        "N/A": 1,
+        "ok": 68
+      },
+      "runner_sha256": "6161fe0101aefb292be6c184139fab53bf7d323d41a829ab42acefbd3b6497e5",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "lzjb-logical-offset-v1-9abdc80f9d1d"
+    },
+    {
+      "all_aggregate_ids_sha256": "d497478804b3b649930470bdc28af6753e768d8e6ef12ff9380ef641ca8bf4d7",
+      "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/by_dataset/jovian_lightning/cold/fc2951b9d14a0de9.jsonl",
+      "cold_rows": 69,
+      "cold_sha256": "1c79afbb8b90e6f4f2d09a3a7612571560516c6cb3b960325b92b68ff3ebc312",
+      "cold_status_counts": {
+        "ok": 69
+      },
+      "dataset_id": "jovian_lightning",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/full/blocks.jsonl",
+        "catalog_sha256": "fa530831a22eadb3ea5eaf1ae7476428f511828ece554e2e0e88f95c88a53f01",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/input_integrity/jovian_lightning.json",
+        "input_integrity_audit_sha256": "55477cb263d6ce7b9997d50f66b296c38a58b4b1694da6b6d7069d24210ba6aa",
+        "input_integrity_segment_descriptor_sha256_chain": "09ab4615e6316ea10216a0ae562166c3ad02237365e474b958dbedec287e4069",
+        "input_integrity_typed_file_sha256_chain": "5c13312301ee850edcc8400046b3482183b3ff90e286677b7f3b65841c728ee8",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/dataset_manifest.json",
+        "manifest_sha256": "45fe6083f19b1b0410437b462c16c4145d6ad95be2e6749cb5081b5377a6dc5f",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/READY.json",
+        "ready_sha256": "e9c1390e477234f3520071d501b77cc99353847f966a3fa99595704b2982937a"
+      },
+      "method": "LZSSE",
+      "method_id": "fc2951b9d14a0de9",
+      "numeric_ok_aggregate_count": 68,
+      "numeric_ok_aggregate_ids_sha256": "6983f0e7cbed77f744e8ba7019e8786e9ad2d3ddd4d0f2eb23bfbbc729d51918",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/by_dataset/jovian_lightning/receipts/fc2951b9d14a0de9.json",
+      "receipt_sha256": "735679615f2dffb84a74a58efe32c46e73b8e6e0d3441998b4940b763f56c491",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/by_dataset/jovian_lightning/results/fc2951b9d14a0de9.jsonl",
+      "result_rows": 69,
+      "result_sha256": "63f649cd0bad347efe95ea50081fc8b431a1432ca9c5332108b16138f26e5dc6",
+      "result_status_counts": {
+        "N/A": 1,
+        "ok": 68
+      },
+      "runner_sha256": "41fefd33b5c642b4780ebf924ed90cf536f309b0644a32372ad5ad9af3ab17b3",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "lzsse-control-block-v1-3452a998adb5"
+    },
+    {
+      "all_aggregate_ids_sha256": "d497478804b3b649930470bdc28af6753e768d8e6ef12ff9380ef641ca8bf4d7",
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/jovian_lightning/cold/3582d91acb1d5e8b.jsonl",
+      "cold_rows": 69,
+      "cold_sha256": "57bac8745c990fc31ebba9238770a49e8f66f27eb52ba4441428910c3fcf1a4b",
+      "cold_status_counts": {
+        "ok": 69
+      },
+      "dataset_id": "jovian_lightning",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/full/blocks.jsonl",
+        "catalog_sha256": "fa530831a22eadb3ea5eaf1ae7476428f511828ece554e2e0e88f95c88a53f01",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/input_integrity/jovian_lightning.json",
+        "input_integrity_audit_sha256": "8e60ced5f6c68bf3c6196cfce67f97a5f2e3d3c1a8105ddf6c4d4e99b8c39395",
+        "input_integrity_segment_descriptor_sha256_chain": "09ab4615e6316ea10216a0ae562166c3ad02237365e474b958dbedec287e4069",
+        "input_integrity_typed_file_sha256_chain": "5c13312301ee850edcc8400046b3482183b3ff90e286677b7f3b65841c728ee8",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/dataset_manifest.json",
+        "manifest_sha256": "45fe6083f19b1b0410437b462c16c4145d6ad95be2e6749cb5081b5377a6dc5f",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/jovian_lightning/READY.json",
+        "ready_sha256": "e9c1390e477234f3520071d501b77cc99353847f966a3fa99595704b2982937a"
+      },
+      "method": "Tornado",
+      "method_id": "3582d91acb1d5e8b",
+      "numeric_ok_aggregate_count": 68,
+      "numeric_ok_aggregate_ids_sha256": "6983f0e7cbed77f744e8ba7019e8786e9ad2d3ddd4d0f2eb23bfbbc729d51918",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/jovian_lightning/receipts/3582d91acb1d5e8b.json",
+      "receipt_sha256": "4677a59e934ca7cb41a91e8f7bb4f3fe9218545fac1a1dd3632deba231cb5b73",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/jovian_lightning/results/3582d91acb1d5e8b.jsonl",
+      "result_rows": 69,
+      "result_sha256": "1ca7ad108b420715a63fb54532eda3cce6c86a71115232b55a502286a86ee9b3",
+      "result_status_counts": {
+        "N/A": 1,
+        "ok": 68
+      },
+      "runner_sha256": "6161fe0101aefb292be6c184139fab53bf7d323d41a829ab42acefbd3b6497e5",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "tornado-min-buffer-v1-39dc8c5d9287"
+    },
+    {
+      "all_aggregate_ids_sha256": "d001f1ae6051159c6e513958d01bd9f18fd469ada6319d5aeb9c96185093e518",
+      "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_failed_once_original_v2/by_dataset/macroecon/cold/eb5350fc4446a37c.jsonl",
+      "cold_rows": 647,
+      "cold_sha256": "23c9f8b9a6ca6eda4973c2daf362832b7104b58e5ad5614ca28586fd42382545",
+      "cold_status_counts": {
+        "ok": 647
+      },
+      "dataset_id": "macroecon",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/full/blocks.jsonl",
+        "catalog_sha256": "624c925aa424a96a303435714699e574218903bedf9ca264337e6ac379e5787a",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_failed_once_original_v2/input_integrity/macroecon.json",
+        "input_integrity_audit_sha256": "7646cc5f6f96aa2d8bb6a11b3c99cdbe17a4026102dc2ac05e0b42bd1116551a",
+        "input_integrity_segment_descriptor_sha256_chain": "7edadef49d7860a31e6eb760162fa0242c5d705148302e1b6518b4444a772f3d",
+        "input_integrity_typed_file_sha256_chain": "ab4383555f7e5976f4baa0b3ee9955ea7bb709391c097bff8157db022a7b65ea",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/dataset_manifest.json",
+        "manifest_sha256": "f12f542e6ca643e76cbb509be89f7c260c9cb0022b5b464599b9287c2cc28d09",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/READY.json",
+        "ready_sha256": "d604594f53944eae265798594480acaee256136c6bc0968036f5edd53310ef39"
+      },
+      "method": "CSC",
+      "method_id": "eb5350fc4446a37c",
+      "numeric_ok_aggregate_count": 571,
+      "numeric_ok_aggregate_ids_sha256": "254ada56801b16f04aac3b53b91b38f0f20986b5a713d5f07e81c66cc1132d9e",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_failed_once_original_v2/by_dataset/macroecon/receipts/eb5350fc4446a37c.json",
+      "receipt_sha256": "061bdbb5984b34a0dc683d947ae436dd8e0e2a0487b845c30b8d7a60968a3268",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_failed_once_original_v2/by_dataset/macroecon/results/eb5350fc4446a37c.jsonl",
+      "result_rows": 647,
+      "result_sha256": "541911b7e49607f9a2fabb3f24c8f693dd1d98e8926c759b070b809bb898584b",
+      "result_status_counts": {
+        "N/A": 76,
+        "ok": 571
+      },
+      "runner_sha256": "6161fe0101aefb292be6c184139fab53bf7d323d41a829ab42acefbd3b6497e5",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "original-458a218fd2e8"
+    },
+    {
+      "all_aggregate_ids_sha256": "d001f1ae6051159c6e513958d01bd9f18fd469ada6319d5aeb9c96185093e518",
+      "binary_sha256": "9abdc80f9d1d6aeba52a93af9648e37fef964fb57b056b0716a31990e828c48b",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/by_dataset/macroecon/cold/30405ccbe4d82992.jsonl",
+      "cold_rows": 647,
+      "cold_sha256": "a5cfc95a2bb08ed59682685fe71af0393b2ffc4ce2a05b8d03c9fa0929803e0e",
+      "cold_status_counts": {
+        "ok": 647
+      },
+      "dataset_id": "macroecon",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/full/blocks.jsonl",
+        "catalog_sha256": "624c925aa424a96a303435714699e574218903bedf9ca264337e6ac379e5787a",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/input_integrity/macroecon.json",
+        "input_integrity_audit_sha256": "afb5a87d0dcdcfce9b83982408606be84b0410e073e05f0ce016edfc46f7103d",
+        "input_integrity_segment_descriptor_sha256_chain": "7edadef49d7860a31e6eb760162fa0242c5d705148302e1b6518b4444a772f3d",
+        "input_integrity_typed_file_sha256_chain": "ab4383555f7e5976f4baa0b3ee9955ea7bb709391c097bff8157db022a7b65ea",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/dataset_manifest.json",
+        "manifest_sha256": "f12f542e6ca643e76cbb509be89f7c260c9cb0022b5b464599b9287c2cc28d09",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/READY.json",
+        "ready_sha256": "d604594f53944eae265798594480acaee256136c6bc0968036f5edd53310ef39"
+      },
+      "method": "LZJB",
+      "method_id": "30405ccbe4d82992",
+      "numeric_ok_aggregate_count": 571,
+      "numeric_ok_aggregate_ids_sha256": "254ada56801b16f04aac3b53b91b38f0f20986b5a713d5f07e81c66cc1132d9e",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/by_dataset/macroecon/receipts/30405ccbe4d82992.json",
+      "receipt_sha256": "603ab98dde0efff2eaea20dfa35a676a03527fc5fe364a58d27c64466301de27",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzjb_logical_offset_v2/by_dataset/macroecon/results/30405ccbe4d82992.jsonl",
+      "result_rows": 647,
+      "result_sha256": "1ff29f6c69ae28c6ec4edf6c509445b4cd92430c9703667f74d8d73c0db1dd8f",
+      "result_status_counts": {
+        "N/A": 76,
+        "ok": 571
+      },
+      "runner_sha256": "6161fe0101aefb292be6c184139fab53bf7d323d41a829ab42acefbd3b6497e5",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "lzjb-logical-offset-v1-9abdc80f9d1d"
+    },
+    {
+      "all_aggregate_ids_sha256": "d001f1ae6051159c6e513958d01bd9f18fd469ada6319d5aeb9c96185093e518",
+      "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/by_dataset/macroecon/cold/fc2951b9d14a0de9.jsonl",
+      "cold_rows": 647,
+      "cold_sha256": "ab80dc4c46937b237827a3e0eef333caae6ca545f9fcc1b04c0f55297aa57618",
+      "cold_status_counts": {
+        "ok": 647
+      },
+      "dataset_id": "macroecon",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/full/blocks.jsonl",
+        "catalog_sha256": "624c925aa424a96a303435714699e574218903bedf9ca264337e6ac379e5787a",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/input_integrity/macroecon.json",
+        "input_integrity_audit_sha256": "4aedd57bb74e41e8f8b77711ef78bbb3cf5e7f8b8712be992a097b6a3d5e7104",
+        "input_integrity_segment_descriptor_sha256_chain": "7edadef49d7860a31e6eb760162fa0242c5d705148302e1b6518b4444a772f3d",
+        "input_integrity_typed_file_sha256_chain": "ab4383555f7e5976f4baa0b3ee9955ea7bb709391c097bff8157db022a7b65ea",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/dataset_manifest.json",
+        "manifest_sha256": "f12f542e6ca643e76cbb509be89f7c260c9cb0022b5b464599b9287c2cc28d09",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/READY.json",
+        "ready_sha256": "d604594f53944eae265798594480acaee256136c6bc0968036f5edd53310ef39"
+      },
+      "method": "LZSSE",
+      "method_id": "fc2951b9d14a0de9",
+      "numeric_ok_aggregate_count": 571,
+      "numeric_ok_aggregate_ids_sha256": "254ada56801b16f04aac3b53b91b38f0f20986b5a713d5f07e81c66cc1132d9e",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/by_dataset/macroecon/receipts/fc2951b9d14a0de9.json",
+      "receipt_sha256": "c569a80ddd8e9757fff1d7ce8a2ccf0d00c1c087f43c6b4e956e5a41414c1616",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_lzsse_control_block_v1/by_dataset/macroecon/results/fc2951b9d14a0de9.jsonl",
+      "result_rows": 647,
+      "result_sha256": "9f6357ff7929a1816827572b24bc0c853b9c31aab432d6aae4870012acbc1b0e",
+      "result_status_counts": {
+        "N/A": 76,
+        "ok": 571
+      },
+      "runner_sha256": "41fefd33b5c642b4780ebf924ed90cf536f309b0644a32372ad5ad9af3ab17b3",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "lzsse-control-block-v1-3452a998adb5"
+    },
+    {
+      "all_aggregate_ids_sha256": "d001f1ae6051159c6e513958d01bd9f18fd469ada6319d5aeb9c96185093e518",
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/macroecon/cold/3582d91acb1d5e8b.jsonl",
+      "cold_rows": 647,
+      "cold_sha256": "a8a5731c52473a04af515d4b2d9757f9afe29f5091411ddc97c492abb3dd9f19",
+      "cold_status_counts": {
+        "ok": 647
+      },
+      "dataset_id": "macroecon",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/full/blocks.jsonl",
+        "catalog_sha256": "624c925aa424a96a303435714699e574218903bedf9ca264337e6ac379e5787a",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/input_integrity/macroecon.json",
+        "input_integrity_audit_sha256": "538526bb3ab03450458b36e9085fa5993f7b34f1c0f5ffc85d28141f4dfdc6e8",
+        "input_integrity_segment_descriptor_sha256_chain": "7edadef49d7860a31e6eb760162fa0242c5d705148302e1b6518b4444a772f3d",
+        "input_integrity_typed_file_sha256_chain": "ab4383555f7e5976f4baa0b3ee9955ea7bb709391c097bff8157db022a7b65ea",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/dataset_manifest.json",
+        "manifest_sha256": "f12f542e6ca643e76cbb509be89f7c260c9cb0022b5b464599b9287c2cc28d09",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/macroecon/READY.json",
+        "ready_sha256": "d604594f53944eae265798594480acaee256136c6bc0968036f5edd53310ef39"
+      },
+      "method": "Tornado",
+      "method_id": "3582d91acb1d5e8b",
+      "numeric_ok_aggregate_count": 571,
+      "numeric_ok_aggregate_ids_sha256": "254ada56801b16f04aac3b53b91b38f0f20986b5a713d5f07e81c66cc1132d9e",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/macroecon/receipts/3582d91acb1d5e8b.json",
+      "receipt_sha256": "970543283d1f4fb85ccda2e18fd8bb0c73d645cfccac5d422d02d72beac1233c",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/macroecon/results/3582d91acb1d5e8b.jsonl",
+      "result_rows": 647,
+      "result_sha256": "d4589e6b3845803289ce962492a6a06b7b9622e7a5296c40ba2e6e4f179b04a1",
+      "result_status_counts": {
+        "N/A": 76,
+        "ok": 571
+      },
+      "runner_sha256": "6161fe0101aefb292be6c184139fab53bf7d323d41a829ab42acefbd3b6497e5",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "tornado-min-buffer-v1-39dc8c5d9287"
+    },
+    {
+      "all_aggregate_ids_sha256": "8ce660b95d1b4e3b0961e2887cadcf5812f92fa561ba3bf366a4b9eb0c1f184a",
+      "binary_sha256": "39dc8c5d9287ddc31aff21474e20c5c65880991a40f6d3f096f870ba22d89bf5",
+      "cold_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/weather_data_NC/cold/3582d91acb1d5e8b.jsonl",
+      "cold_rows": 16,
+      "cold_sha256": "d9df5f504cbfbffc1f7fc02faed6dc087d6597d195ffe7a68ce68ac981538a24",
+      "cold_status_counts": {
+        "ok": 16
+      },
+      "dataset_id": "weather_data_NC",
+      "epoch_cohort": "new",
+      "fresh_cold_process": true,
+      "gate": {
+        "catalog_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/weather_data_NC/full/blocks.jsonl",
+        "catalog_sha256": "c81810e9f996cc58e2c5035a835f4b59f868f2a26ca850c555dd9ce37eba1d0f",
+        "input_integrity_audit_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/input_integrity/weather_data_NC.json",
+        "input_integrity_audit_sha256": "65fae76626a23f26e12a1214c8f3f5b0e8cad0f3cacd861f4f32e4446bed8cfc",
+        "input_integrity_segment_descriptor_sha256_chain": "a2d62e2b07dfb87809cd90477e8c0e098365bdfdf1f593384d27e784ceea044a",
+        "input_integrity_typed_file_sha256_chain": "f9804630690e69ea76d7da67bdde0019b16a7a3291f05f8829d810c89013fbc0",
+        "manifest_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/weather_data_NC/dataset_manifest.json",
+        "manifest_sha256": "de525156ffb67cf1c24bd3043c28f16db0da84b007112477e68f2589199b80e0",
+        "ready_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/preparation/typed_streams/datasets/weather_data_NC/READY.json",
+        "ready_sha256": "037079da1e49654d57503b023a682161ab4fe15a421d269aed2ef27b7f8ba642"
+      },
+      "method": "Tornado",
+      "method_id": "3582d91acb1d5e8b",
+      "numeric_ok_aggregate_count": 15,
+      "numeric_ok_aggregate_ids_sha256": "ac5f20bf86e3fee61567386f5f6634e47b360550a5b50c0957cb84bd943e90a1",
+      "rate_and_bytes_admission": "receipt_result_cold_sha_bound",
+      "receipt_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/weather_data_NC/receipts/3582d91acb1d5e8b.json",
+      "receipt_sha256": "b0b4f95c5bd701c33df16948793e5608a92f73f802ae088d9747f05ac41e76ea",
+      "result_path": "/data/user/new_ai_compress/operator_sweep/paper172_20261007_v1/runtime/failure_recovery/native_tornado_min_buffer_v2/by_dataset/weather_data_NC/results/3582d91acb1d5e8b.jsonl",
+      "result_rows": 16,
+      "result_sha256": "ed6bbc9a54de76a7f27941b8629f1f2b773fb3bbb6175bdcc364c97c9f49a0bc",
+      "result_status_counts": {
+        "N/A": 1,
+        "ok": 15
+      },
+      "runner_sha256": "6161fe0101aefb292be6c184139fab53bf7d323d41a829ab42acefbd3b6497e5",
+      "timing_admission": "diagnostic_per_variant_until_independent_source_build_boundary_proof",
+      "variant_id": "tornado-min-buffer-v1-39dc8c5d9287"
+    }
+  ]
+}

native86-terminal-matrix.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9
+size 2379769

native86-v9-current154-thin.jsonl.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f538e84dd2b4fee3c1b0d68408095fc88714eafe3ac0e6a57d6dc674f39e47a0
+size 753807

package_next5_external_results.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Package the verified next5/AppleDouble campaign for append-only sync to 166."""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import hashlib
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+
+CAMPAIGN_ID = "next5_native_recovery_192_20261010_v1"
+HOST = "192.168.99.20"
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def load(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError(f"Expected an object in {path}")
+    return value
+
+
+def file_record(path: Path, *, root: Path) -> dict[str, Any]:
+    return {
+        "path": path.relative_to(root).as_posix(),
+        "bytes": path.stat().st_size,
+        "sha256": sha256(path),
+    }
+
+
+def copy(source: Path, destination: Path) -> None:
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source, destination)
+
+
+def package(source: Path, output: Path) -> dict[str, Any]:
+    final_source = source / "repairs/appledouble_inventory_v1/FINAL_REPAIRED_INDEPENDENT_VERIFICATION.json"
+    final = load(final_source)
+    if final.get("status") != "verified" or final.get("result_execution_host") != HOST:
+        raise ValueError("The next5 final receipt is not verified on host 192")
+    if final.get("timing_hardware_comparability") != "host192_only_not_comparable_to166":
+        raise ValueError("The next5 final receipt lost its host timing boundary")
+    formal = output / "formal_native86"
+    central = formal / "external_results" / CAMPAIGN_ID / "source_192"
+    final_target = central / final_source.name
+    copy(final_source, final_target)
+    quarantine_source = source / "diagnostics/appledouble_metadata_20261010/APPLEDOUBLE_QUARANTINE_RECEIPT.json"
+    quarantine_target = central / "APPLEDOUBLE_QUARANTINE_RECEIPT.json"
+    copy(quarantine_source, quarantine_target)
+    manifest_source = source / "CAMPAIGN_MANIFEST.json"
+    manifest_target = central / "CAMPAIGN_MANIFEST.source192.json"
+    copy(manifest_source, manifest_target)
+
+    profiles: list[dict[str, Any]] = []
+    for item in final["pairs"]:
+        key = str(item["selection_key_hex"])
+        raw_dataset, raw_method_id = bytes.fromhex(key).split(b"\0", 1)
+        dataset = raw_dataset.decode("utf-8")
+        method_id = raw_method_id.decode("ascii")
+        if dataset != item["dataset_id"]:
+            raise ValueError(f"Selection key dataset mismatch: {key}")
+        source_pair = source / "pairs" / key
+        verification_source = source_pair / "INDEPENDENT_VERIFICATION.json"
+        if item["admission_source"] == "replacement_reverification":
+            verification_source = source / "repairs/appledouble_inventory_v1/pairs" / key / "INDEPENDENT_VERIFICATION.json"
+        verification = load(verification_source)
+        if verification.get("status") != "verified" or verification.get("result_execution_host") != HOST:
+            raise ValueError(f"Pair verification failed: {verification_source}")
+        target = formal / "by_dataset" / dataset / "external_results" / method_id / CAMPAIGN_ID
+        results_target = target / "results.jsonl"
+        cold_target = target / "cold.jsonl"
+        verification_target = target / "INDEPENDENT_VERIFICATION.source192.json"
+        original_terminal_target = target / "ORIGINAL_PAIR_TERMINAL.source192.json"
+        copy(source_pair / "results.jsonl", results_target)
+        copy(source_pair / "cold.jsonl", cold_target)
+        copy(verification_source, verification_target)
+        copy(source_pair / "state/PAIR_TERMINAL.json", original_terminal_target)
+        if sha256(results_target) != item["results_sha256"] or sha256(cold_target) != item["cold_sha256"]:
+            raise ValueError(f"Pair result hash mismatch: {key}")
+        if sha256(verification_target) != item["verification_sha256"]:
+            raise ValueError(f"Pair verification hash mismatch: {key}")
+        supplemental: dict[str, Any] | None = None
+        if item["admission_source"] == "replacement_reverification":
+            repair_source = source / "repairs/appledouble_inventory_v1/pairs" / key / "REPAIR_TERMINAL.json"
+            repair_target = target / "REPAIR_TERMINAL.source192.json"
+            copy(repair_source, repair_target)
+            supplemental = file_record(repair_target, root=formal)
+        profile = {
+            "schema": "paper164-native-external-method-profile-entry-v1",
+            "status": "externally_verified_complete",
+            "campaign_id": CAMPAIGN_ID,
+            "dataset_id": dataset,
+            "method": str(item["method"]),
+            "method_id": method_id,
+            "selection_key_hex": key,
+            "result_execution_host": HOST,
+            "timing_host_preserved": HOST,
+            "result_rows": int(item["aggregate_count"]),
+            "cold_rows": int(item["aggregate_count"]),
+            "aggregate_count": int(item["aggregate_count"]),
+            "independently_admitted_rows": int(item["aggregate_count"]),
+            "benchmark_provenance": "complete_benchmark_and_cold_in_selected_source_job",
+            "admission": {
+                "formal166_receipt_replaced": False,
+                "old_166_failure_history_preserved": True,
+                "ratio_and_lossless": "admitted_by_source192_independent_verifier",
+                "timing": "external_host_only_not_admitted_as_166_timing",
+                "verification_source": str(item["admission_source"]),
+            },
+            "files": {
+                "results.jsonl": file_record(results_target, root=formal),
+                "cold.jsonl": file_record(cold_target, root=formal),
+                "INDEPENDENT_VERIFICATION.source192.json": file_record(verification_target, root=formal),
+                "ORIGINAL_PAIR_TERMINAL.source192.json": file_record(original_terminal_target, root=formal),
+            },
+            "final_campaign_verification": file_record(final_target, root=formal),
+            "appledouble_quarantine_receipt": file_record(quarantine_target, root=formal),
+            "campaign_manifest": file_record(manifest_target, root=formal),
+            "source_job_root": f"/data/root/web_compression/next5_native_recovery_20261010_v1/pairs/{key}",
+            "frames": {
+                "copied_to166": False,
+                "location": "retained_on_source192",
+                "source_root": f"/data/root/web_compression/next5_native_recovery_20261010_v1/pairs/{key}/frames",
+            },
+        }
+        if supplemental is not None:
+            profile["files"]["REPAIR_TERMINAL.source192.json"] = supplemental
+        profile_path = target / "PROFILE_ENTRY.json"
+        profile_path.write_text(
+            json.dumps(profile, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+            encoding="utf-8",
+        )
+        profiles.append({
+            "dataset_id": dataset,
+            "method": item["method"],
+            "method_id": method_id,
+            "aggregate_count": item["aggregate_count"],
+            "profile_entry": file_record(profile_path, root=formal),
+        })
+    if len(profiles) != 5 or sum(int(item["aggregate_count"]) for item in profiles) != 280:
+        raise ValueError("The next5 package must contain exactly 5 pairs and 280 aggregates")
+    # Exclude a manifest left by an earlier idempotent rebuild: a manifest
+    # cannot safely bind its own bytes.
+    files = [
+        file_record(path, root=output)
+        for path in sorted(output.rglob("*"))
+        if path.is_file() and path != output / "PACKAGE_MANIFEST.json"
+    ]
+    package_manifest = {
+        "schema": "paper164-next5-external-results-package-v1",
+        "status": "verified_ready_for_append_only_sync",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "campaign_id": CAMPAIGN_ID,
+        "result_execution_host": HOST,
+        "timing_hardware_comparability": "host192_only_not_comparable_to166",
+        "pair_count": len(profiles),
+        "aggregate_count": sum(int(item["aggregate_count"]) for item in profiles),
+        "profiles": profiles,
+        "joint_verifier": file_record(final_target, root=formal),
+        "files": files,
+    }
+    manifest_path = output / "PACKAGE_MANIFEST.json"
+    manifest_path.write_text(
+        json.dumps(package_manifest, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    return {**package_manifest, "package_manifest_sha256": sha256(manifest_path)}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    receipt = package(args.source.resolve(), args.output.resolve())
+    print(json.dumps({
+        "status": receipt["status"], "pairs": receipt["pair_count"],
+        "aggregates": receipt["aggregate_count"],
+        "package_manifest_sha256": receipt["package_manifest_sha256"],
+    }, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ranking.js

@@ -10,7 +10,8 @@ export function parseWeights(value) {
 }
 
 const finite=v=>v!==null&&v!==undefined&&Number.isFinite(v);
-const valid=r=>finite(r.compression_rate)&&r.compression_rate>0&&finite(r.compression_time)&&r.compression_time>=0&&finite(r.decompression_time)&&r.decompression_time>=0;
+const timingAdmitted=r=>Array.isArray(r.source)?r.source.every(timingAdmitted):/^timing_admitted_/i.test(String(r.timing_profile_status??''));
+const valid=r=>finite(r.compression_rate)&&r.compression_rate>0&&finite(r.compression_time)&&r.compression_time>=0&&finite(r.decompression_time)&&r.decompression_time>=0&&timingAdmitted(r);
 const average=values=>values.length?values.reduce((s,v)=>s+v,0)/values.length:null;
 
 function bounds(rows,key) {
@@ -31,13 +32,17 @@ function score(row,weights,encodeRange,decodeRange) {
 export function addRankingMetrics(rows,weights) {
   if(weights.length!==3||weights.some(w=>!finite(w)||w<0)||Math.abs(weights.reduce((s,w)=>s+w,0)-1)>1e-12)throw new Error('Invalid scoring weights.');
   const candidates=rows.filter(r=>valid(r)&&r.source.every(valid));
-  const encodeRange=bounds(candidates,'compression_time'),decodeRange=bounds(candidates,'decompression_time');
+  const workloadSignature=row=>row.source.map(r=>`${r.dataset}:${r.eligible_column_set_sha256??'legacy_snapshot_unbound'}`).sort().join('|');
+  const workloadSignatures=new Set(candidates.map(workloadSignature));
+  const globallyComparable=workloadSignatures.size<=1;
+  const encodeRange=globallyComparable?bounds(candidates,'compression_time'):null,decodeRange=globallyComparable?bounds(candidates,'decompression_time'):null;
   const byDataset=new Map(),ranks=new Map(),details=new Map();
   for(const row of rows) {
     ranks.set(row.method,[]);
     for(const record of row.source.filter(valid)) {
-      if(!byDataset.has(record.dataset))byDataset.set(record.dataset,[]);
-      byDataset.get(record.dataset).push({...record,method:row.method});
+      const cohort=`${record.dataset}\0${record.eligible_column_set_sha256??'legacy_snapshot_unbound'}`;
+      if(!byDataset.has(cohort))byDataset.set(cohort,[]);
+      byDataset.get(cohort).push({...record,method:row.method});
     }
   }
   for(const records of byDataset.values()) {
@@ -49,10 +54,10 @@ export function addRankingMetrics(rows,weights) {
       const rank=(start+1+end)/2;
       for(let i=start;i<end;i++) {
         ranks.get(ordered[i].method).push(rank);
-        details.set(`${ordered[i].method}\0${ordered[i].dataset}`,{dataset_score:ordered[i].composite_score,dataset_rank:rank,dataset_candidate_count:ordered.length});
+        details.set(`${ordered[i].method}\0${ordered[i].dataset}\0${ordered[i].eligible_column_set_sha256??'legacy_snapshot_unbound'}`,{dataset_score:ordered[i].composite_score,dataset_rank:rank,dataset_candidate_count:ordered.length});
       }
       start=end;
     }
   }
-  return rows.map(row=>({...row,...(candidates.includes(row)?score(row,weights,encodeRange,decodeRange):{normalized_compression_time:null,normalized_decompression_time:null,composite_score:null}),average_rank:average(ranks.get(row.method)),rank_coverage:ranks.get(row.method).length,normalization_reference_rows:candidates.length,encode_min:encodeRange?.[0]??null,encode_max:encodeRange?.[1]??null,decode_min:decodeRange?.[0]??null,decode_max:decodeRange?.[1]??null,source:row.source.map(r=>({...r,...details.get(`${row.method}\0${r.dataset}`)}))}));
+  return rows.map(row=>({...row,...(globallyComparable&&candidates.includes(row)?score(row,weights,encodeRange,decodeRange):{normalized_compression_time:null,normalized_decompression_time:null,composite_score:null}),average_rank:average(ranks.get(row.method)),rank_coverage:ranks.get(row.method).length,normalization_reference_rows:globallyComparable?candidates.length:0,workload_signature_count:workloadSignatures.size,encode_min:encodeRange?.[0]??null,encode_max:encodeRange?.[1]??null,decode_min:decodeRange?.[0]??null,decode_max:decodeRange?.[1]??null,source:row.source.map(r=>({...r,...details.get(`${row.method}\0${r.dataset}\0${r.eligible_column_set_sha256??'legacy_snapshot_unbound'}`)}))}));
 }

reference-catalog.json

@@ -261,14 +261,6 @@
         "M08"
       ]
     },
-    {
-      "family": "GLZA",
-      "display_name": "GLZA",
-      "description": "GLZA first applies data-aware preprocessing such as text capitalization coding or strided delta filtering when applicable. It recursively replaces profitable repeated sequences with grammar production rules, then encodes the resulting Grammatical Ziv-Lempel symbols with statistical models.",
-      "reference_ids": [
-        "M34"
-      ]
-    },
     {
       "family": "GORILLA",
       "display_name": "Gorilla",
@@ -2549,14 +2541,6 @@
       "source_slide": 2,
       "verification_status": "link_reachable_2026-10-08_content_from_ppt_notes"
     },
-    {
-      "id": "M34",
-      "citation": "Kennon Conrad. “GLZA Compression Toolset.” Official source distribution mirror, 2016.",
-      "url": "https://github.com/jrmuizel/GLZA",
-      "kind": "archived_project_page_or_source_mirror",
-      "source_slide": 2,
-      "verification_status": "link_reachable_2026-10-08_content_from_ppt_notes"
-    },
     {
       "id": "M35",
       "citation": "MATCODE Software. “LZMAT: Open-source Extremely Fast Data Compression Library, Version 1.0.” Official project documentation (archived), 2008.",
@@ -3443,14 +3427,6 @@
         ],
         "family": "Gipfeli"
       },
-      {
-        "index": 36,
-        "ppt_name": "GLZA",
-        "reference_ids": [
-          "M34"
-        ],
-        "family": "GLZA"
-      },
       {
         "index": 37,
         "ppt_name": "LZMAT",