Bootstrap category-first AISimulate data storage

Signed-off-by: Simone Chen <simonec@nvidia.com>

.github/workflows/validate.yaml

@@ -0,0 +1,21 @@
+name: Validate dataset
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: true
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: python -m pip install -e '.[dev]'
+      - run: python scripts/validate.py
+      - run: python scripts/build_catalog.py --check
+      - run: pytest

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/

CONTRIBUTING.md

@@ -0,0 +1,37 @@
+# Contributing data
+
+## Storage contract
+
+- Choose exactly one category: `op-latency`, `e2e`, or `fpm`.
+- Put collection/source IDs under `provenance/`, never in the primary hierarchy.
+- Keep one effective configuration per leaf.
+- Keep requested and effective configuration separate. Record every observed
+  override in `differences.yaml` and cite its evidence.
+- Declare each stored artifact with path, role, format, SHA-256, byte size, and
+  row count when tabular.
+- Represent missing, failed, excluded, and unavailable evidence explicitly.
+- Do not edit generated `catalog.yaml` files by hand.
+
+| Category | Primary hierarchy | Must not contain |
+| --- | --- | --- |
+| Operation latency | hardware / operation family / framework / version | model or parallelism identity |
+| E2E | model / hardware / framework / version / parallelism | mixed effective configurations |
+| FPM | model / hardware / framework / version / parallelism | mixed effective configurations |
+
+Directory components are case-sensitive. `deepseek-ai/DeepSeek-V4-Pro` becomes
+`deepseek-ai--DeepSeek-V4-Pro`.
+
+## New-model evidence
+
+New AISimulate model support must link E2E silicon evidence and a gap analysis
+against pinned dataset and AISimulate revisions. FPM evidence is optional initially.
+A failed or unsupported Replay cell must remain visible with its reason; an
+analytical estimate is not a Replay substitute.
+
+## Third-party imports
+
+Include the upstream license, immutable revision, run and artifact IDs, original
+recipe, reconciliation notes, and an unofficial-result notice. Label normalized
+or compressed derivatives.
+
+Run the validator, catalog check, and tests before submitting a pull request.

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 SemiAnalysis LLC, Advanced Micro Devices, NVIDIA CORPORATION
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,3 +1,41 @@
 ---
 license: apache-2.0
 ---
+# AISimulate data
+
+Central, reproducible evidence for AISimulate calibration and regression checks.
+
+## Layout
+
+```text
+data/
+  op-latency/<hardware>/<operation-family>/<framework>/<version>/
+  e2e/<org>--<model>/<hardware>/<framework>/<version>/<parallelism>/
+  fpm/<org>--<model>/<hardware>/<framework>/<version>/<parallelism>/
+```
+
+Each leaf has one effective configuration and one authoritative `manifest.yaml`.
+Collection and source IDs appear only below `provenance/`. Large tables use
+Parquet, event streams may use JSONL, and compressed logs use `.log.zst`.
+
+Model directory names preserve the case of the Hugging Face model ID and replace
+`/` with `--`. Parallelism names are readable (`tp4`, `tep8`, `dep8`).
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the full contract and contribution
+policy. Schemas are human-readable YAML files in `schemas/`.
+
+## Validate
+
+```bash
+python -m pip install -e '.[dev]'
+python scripts/validate.py
+python scripts/build_catalog.py --check
+pytest
+```
+
+## Third-party data
+
+Imported evidence retains source revisions, artifact identities, hashes, and
+license attribution. InferenceX-derived records are unofficial normalized copies,
+not results published or endorsed by the InferenceX maintainers. See
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md).

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,16 @@
+# Third-party notices
+
+## InferenceX
+
+Some records are derived from the InferenceX project:
+
+- Project: https://github.com/SemiAnalysisAI/InferenceX
+- License: Apache License 2.0
+- Copyright: the InferenceX contributors
+
+Each imported leaf pins its upstream commit, workflow/run, artifact IDs, original
+recipe, and source hashes. Normalized tables, compressed logs, manifests, and gap
+analysis files are modifications made for this dataset.
+
+All InferenceX-derived content is an **unofficial normalized copy**. It is not an
+official InferenceX result and is not endorsed by its maintainers.

data/catalog.yaml

@@ -0,0 +1,4 @@
+generated: true
+entries:
+- category: e2e
+  manifest: data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/manifest.yaml

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/evaluations/8c4929d3544938b5878430236dd861a7f5412237/gap-analysis.yaml

@@ -0,0 +1,36 @@
+schema_version: gap-analysis/v1
+engine: aisimulate-replay
+dataset:
+  revision: self
+  manifest_path: data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/manifest.yaml
+aisimulate:
+  revision: 8c4929d3544938b5878430236dd861a7f5412237
+workload:
+  input_tokens: 1024
+  output_tokens: 1024
+  concurrency: 16
+  model: deepseek-ai/DeepSeek-V4-Pro
+  hardware: H200
+  framework: vllm
+  framework_version: 0.25.1
+  parallelism: tp8
+results:
+  - metric: ttft
+    measured: 887.0075593702496
+    predicted: null
+    unit: ms
+    absolute_percentage_error: null
+    status: unsupported
+    reason: AISimulate revision does not expose a Replay adapter for DeepSeek-V4-Pro with vLLM 0.25.1.
+  - metric: tpot
+    measured: 24.853891183898143
+    predicted: null
+    unit: ms
+    absolute_percentage_error: null
+    status: unsupported
+    reason: AISimulate revision does not expose a Replay adapter for DeepSeek-V4-Pro with vLLM 0.25.1.
+reconciliation:
+  source_rows: 1
+  normalized_rows: 18
+  values_match: true
+  units: InferenceX seconds converted to milliseconds for Replay comparison.

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/gpu-metrics.parquet

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

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/manifest.yaml

@@ -0,0 +1,83 @@
+schema_version: e2e-manifest/v1
+category: e2e
+model:
+  id: deepseek-ai/DeepSeek-V4-Pro
+  revision: upstream-default-unpinned
+identity:
+  hardware: H200
+  framework: vllm
+  framework_version: 0.25.1
+precision: fp8
+parallelism:
+  label: tp8
+  tp: 8
+  pp: 1
+  dp: 1
+  ep: 1
+  dcp: 1
+  pcp: 1
+deployment:
+  mode: aggregated
+runtime:
+  image: vllm/vllm-openai:v0.25.1
+  image_digest: null
+  command: provenance/inferencex-run-29316772188-attempt-1/recipe.sh
+workload:
+  input_tokens: 1024
+  output_tokens: 1024
+  concurrency: 16
+  arrival_policy: closed-loop maximum concurrency
+  warmup_requests: 0
+  cache_state: prefix cache disabled; engine warmup not reported
+  requested_requests: 160
+  completed_requests: null
+  failed_requests: null
+metrics:
+  - {name: ttft, value: 0.8870075593702496, unit: s, statistic: mean, timing_boundary: InferenceX benchmark client}
+  - {name: ttft, value: 0.4869475280866027, unit: s, statistic: median, timing_boundary: InferenceX benchmark client}
+  - {name: ttft, value: 0.9740721061825742, unit: s, statistic: p90, timing_boundary: InferenceX benchmark client}
+  - {name: ttft, value: 6.155770289283244, unit: s, statistic: p99, timing_boundary: InferenceX benchmark client}
+  - {name: ttft, value: 6.812136084629227, unit: s, statistic: p99.9, timing_boundary: InferenceX benchmark client}
+  - {name: tpot, value: 0.024853891183898143, unit: s, statistic: mean, timing_boundary: InferenceX benchmark client}
+  - {name: tpot, value: 0.02521957511891945, unit: s, statistic: median, timing_boundary: InferenceX benchmark client}
+  - {name: tpot, value: 0.026219733964575737, unit: s, statistic: p90, timing_boundary: InferenceX benchmark client}
+  - {name: tpot, value: 0.027602960369130736, unit: s, statistic: p99, timing_boundary: InferenceX benchmark client}
+  - {name: tpot, value: 0.02823140630432796, unit: s, statistic: p99.9, timing_boundary: InferenceX benchmark client}
+  - {name: itl, value: 0.0248810343796077, unit: s, statistic: mean, timing_boundary: InferenceX benchmark client}
+  - {name: e2e_latency, value: 23.65051023357082, unit: s, statistic: mean, timing_boundary: InferenceX benchmark client}
+  - {name: throughput, value: 153.23358503172562, unit: tokens/s/gpu, statistic: mean, timing_boundary: Full benchmark interval}
+  - {name: input_throughput, value: 77.02243927952071, unit: tokens/s/gpu, statistic: mean, timing_boundary: Full benchmark interval}
+  - {name: output_throughput, value: 76.21114575220491, unit: tokens/s/gpu, statistic: mean, timing_boundary: Full benchmark interval}
+  - {name: power, value: 425.523, unit: W, statistic: mean, timing_boundary: GPU monitor sampling interval}
+  - {name: energy_per_output_token, value: 5.583476, unit: J/token, statistic: mean, timing_boundary: Full benchmark interval}
+  - {name: energy_per_total_token, value: 2.776957, unit: J/token, statistic: mean, timing_boundary: Full benchmark interval}
+sources:
+  - project: InferenceX
+    url: https://github.com/SemiAnalysisAI/InferenceX
+    revision: 1ce6f5be2c2247aa49c29ce768134666ccc9bf93
+    license: Apache-2.0
+    attribution: Copyright InferenceX contributors; unofficial normalized copy.
+    unofficial: true
+    workflow_url: https://github.com/SemiAnalysisAI/InferenceX/actions/runs/29316772188/attempts/1
+    workflow_status: failure
+    artifact_ids: [8309942231, 8309942845, 8309943495]
+artifacts:
+  - {id: measurements, path: measurements.parquet, role: normalized E2E aggregate metrics, format: parquet, schema: e2e-metrics/v1, sha256: 6ffca11ad412e91af3a8a06f1bfcaf018b549868d22795c84b8980aad61a1a13, bytes: 2219, rows: 18, source_sha256: eed429788dbc5bf88673838d5de29a6e6e8e74755e88ddd7b58b297c46a556ba, modified: true}
+  - {id: gpu-metrics, path: gpu-metrics.parquet, role: normalized GPU telemetry, format: parquet, schema: inferencex-gpu-metrics/v1, sha256: b22980a9295a07163fbbe4b312b520f872c5e2794d59831505c98d97dc837d20, bytes: 40383, rows: 10656, source_sha256: 9802227f97a8f64429c1d231ea4c1323ceacc72178b31e80247757c353bfaeb6, modified: true}
+  - {id: source-aggregate, path: provenance/inferencex-run-29316772188-attempt-1/source-aggregate.json, role: original InferenceX aggregate, format: json, schema: inferencex-aggregate, sha256: eed429788dbc5bf88673838d5de29a6e6e8e74755e88ddd7b58b297c46a556ba, bytes: 1680, rows: 1, modified: false}
+  - {id: recipe, path: provenance/inferencex-run-29316772188-attempt-1/recipe.sh, role: original InferenceX recipe, format: shell, schema: null, sha256: 99ec785b68e96b1772d1e49711d17f0ebeaad6b43369cc32da8bee38e28b4aec, bytes: 2764, modified: false}
+  - {id: requested-config, path: provenance/inferencex-run-29316772188-attempt-1/requested-config.yaml, role: requested configuration, format: yaml, schema: requested-config/v1, sha256: 8a948bbe393d97b1cb07c01cbfb6e0ece0b741624c9f6aa25f32ed4e9b90dca0, bytes: 576, modified: true}
+  - {id: effective-config, path: provenance/inferencex-run-29316772188-attempt-1/effective-config.yaml, role: effective configuration recovered from server log, format: yaml, schema: effective-config/v1, sha256: 980d97541280bf87712897c3fd7fd3fe054dd318af76a90abdb81a47882e5459, bytes: 670, modified: true}
+  - {id: config-differences, path: provenance/inferencex-run-29316772188-attempt-1/differences.yaml, role: requested versus effective overrides, format: yaml, schema: config-differences/v1, sha256: 58c43d7b16f2b7fea300405184eb2a9c9d1f6d49971d158a1f28bf4a1700a1c4, bytes: 627, modified: true}
+  - {id: environment, path: provenance/inferencex-run-29316772188-attempt-1/environment.yaml, role: workflow and runner provenance, format: yaml, schema: environment/v1, sha256: ec71d443cfc6db3537c4985d536f8750434f8a05d3a4c67dd3a2b86f36fec490, bytes: 442, modified: true}
+  - {id: server-log, path: provenance/inferencex-run-29316772188-attempt-1/logs/server.log.zst, role: compressed original server log, format: log.zst, schema: null, sha256: ed02bccc4ce91163b20262dda3a8b2ff2dd897988eafa1394ae7bb53fc3ea07f, bytes: 9783, source_sha256: d8e7ea716be224603da9908e54b8ba0d3123654cf2d5c6a992e7522b461580e5, modified: true}
+  - {id: reconciliation, path: provenance/inferencex-run-29316772188-attempt-1/reconciliation.yaml, role: source-to-normalized reconciliation, format: yaml, schema: reconciliation/v1, sha256: 06b5cf36b1affc192f21ca98350368eb0b119e38c51f7560f6fdc791f7d06b65, bytes: 508, modified: true}
+  - {id: gap-analysis, path: evaluations/8c4929d3544938b5878430236dd861a7f5412237/gap-analysis.yaml, role: AISimulate Replay gap analysis, format: yaml, schema: gap-analysis/v1, sha256: fd80c1c1c269b8e1303ef288fdc261f4fa311b5a9194d83556dee96e0c2e356b, bytes: 1082, rows: 2, modified: true}
+evidence_gaps:
+  - {kind: requests, status: unavailable, reason: Selected InferenceX artifact contains aggregate JSON but no request-level export., evidence: artifact 8309942231}
+  - {kind: client-log, status: unavailable, reason: No client log was published for the selected point., evidence: workflow run 29316772188 attempt 1}
+  - {kind: request-accounting, status: unavailable, reason: Aggregate does not report completed or failed request counts., evidence: source-aggregate.json}
+  - {kind: model-revision, status: unavailable, reason: Server initialized with revision=None., evidence: server log line 24}
+  - {kind: image-digest, status: unavailable, reason: Only the mutable image tag was recorded., evidence: source-aggregate.json}
+  - {kind: error-rate, status: unavailable, reason: Aggregate does not report request failures., evidence: source-aggregate.json}
+  - {kind: replay-prediction, status: failed, reason: Exact DeepSeek-V4-Pro vLLM 0.25.1 Replay adapter is unavailable at the pinned AISimulate revision., evidence: evaluations/8c4929d3544938b5878430236dd861a7f5412237/gap-analysis.yaml}

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/measurements.parquet

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

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/differences.yaml

@@ -0,0 +1,19 @@
+differences:
+  - field: max_model_len
+    requested: 800000
+    effective: 2304
+    evidence:
+      - recipe.sh comment
+      - logs/server.log.zst line 7
+      - logs/server.log.zst line 24
+    note: The workflow-provided value overrode the recipe comment.
+  - field: model_revision
+    requested: null
+    effective: null
+    evidence: logs/server.log.zst line 24
+    note: InferenceX did not pin the downloaded Hugging Face model revision.
+  - field: image_digest
+    requested: null
+    effective: null
+    evidence: source-aggregate.json
+    note: The tag was recorded, but the immutable container digest was unavailable.

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/effective-config.yaml

@@ -0,0 +1,26 @@
+evidence: logs/server.log.zst
+model: deepseek-ai/DeepSeek-V4-Pro
+model_revision: null
+framework_version: 0.25.1
+dtype: bfloat16
+quantization: deepseek_v4_fp8
+max_model_len: 2304
+tensor_parallel_size: 8
+pipeline_parallel_size: 1
+data_parallel_size: 1
+expert_parallel_size: 1
+decode_context_parallel_size: 1
+kv_cache_dtype: fp8
+kv_cache_capacity_tokens: 208811
+block_size: 256
+gpu_memory_utilization: 0.95
+prefix_caching: false
+chunked_prefill: true
+max_num_batched_tokens: 512
+max_num_seqs: 512
+compilation_mode: NONE
+cudagraph_mode: FULL_DECODE_ONLY
+max_cudagraph_capture_size: 512
+tokenizer_mode: deepseek_v4
+reasoning_parser: deepseek_v4
+tool_call_parser: deepseek_v4

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/environment.yaml

@@ -0,0 +1,12 @@
+runner: h200-dgxc-slurm_13
+collection_date: '2026-07-14'
+workflow_run: 29316772188
+workflow_attempt: 1
+workflow_status: failure
+selected_job_status: success
+server_artifact_id: 8309942845
+benchmark_artifact_id: 8309942231
+gpu_metrics_artifact_id: 8309943495
+notes:
+  - The workflow failed overall; this selected benchmark point completed successfully.
+  - Host identifiers and full package inventory were not present in downloaded artifacts.

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/logs/server.log.zst

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

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/recipe.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+
+# Per https://vllm.ai/blog/deepseek-v4 the DeepSeek-V4-Pro H200 recipe uses
+# the cu129 image and omits the FP4 indexer cache flag (H200 has no FP4
+# path). Max-model-len is pinned at 800k per the recipe.
+
+source "$(dirname "$0")/../../benchmark_lib.sh"
+
+check_env_vars \
+    MODEL \
+    TP \
+    DP_ATTENTION \
+    CONC \
+    ISL \
+    OSL \
+    MAX_MODEL_LEN \
+    RANDOM_RANGE_RATIO \
+    RESULT_FILENAME
+
+if [[ -n "$SLURM_JOB_ID" ]]; then
+  echo "JOB $SLURM_JOB_ID running on $SLURMD_NODENAME"
+fi
+
+nvidia-smi
+
+if [[ "$MODEL" != /* ]]; then hf download "$MODEL"; fi
+
+SERVER_LOG=/workspace/server.log
+
+# DeepSeek-V4-Pro weights are large; engine startup can exceed the default
+# 600s. Give it an hour to load.
+export VLLM_ENGINE_READY_TIMEOUT_S=3600
+
+if [ "${EVAL_ONLY}" = "true" ]; then
+    setup_eval_context
+    MAX_MODEL_LEN_ARG="--max-model-len $EVAL_MAX_MODEL_LEN"
+else
+    MAX_MODEL_LEN_ARG="--max-model-len $MAX_MODEL_LEN"
+fi
+
+# DP_ATTENTION=true runs DP-attention with expert parallel (DP size = TP);
+# DP_ATTENTION=false runs pure tensor parallel.
+PARALLEL_ARGS=(--tensor-parallel-size "$TP" --data-parallel-size 1)
+if [ "${DP_ATTENTION}" = "true" ]; then
+    PARALLEL_ARGS=(--tensor-parallel-size 1 --data-parallel-size "$TP")
+fi
+
+EP_ARGS=()
+if [ "${EP_SIZE:-1}" -gt 1 ]; then
+    EP_ARGS=(--enable-expert-parallel)
+fi
+
+# Start GPU monitoring (power, temperature, clocks every second)
+start_gpu_monitor
+
+set -x
+vllm serve $MODEL --host 0.0.0.0 --port $PORT \
+--trust-remote-code \
+--kv-cache-dtype fp8 \
+--block-size 256 \
+--no-enable-prefix-caching \
+"${PARALLEL_ARGS[@]}" \
+"${EP_ARGS[@]}" \
+$MAX_MODEL_LEN_ARG \
+--quantization deepseek_v4_fp8 \
+--gpu-memory-utilization 0.95 \
+--max-num-seqs 512 \
+--max-num-batched-tokens 512 \
+--no-enable-flashinfer-autotune \
+--compilation-config '{"mode":0,"cudagraph_mode":"FULL_DECODE_ONLY"}' \
+--tokenizer-mode deepseek_v4 \
+--tool-call-parser deepseek_v4 \
+--enable-auto-tool-choice \
+--reasoning-parser deepseek_v4 > $SERVER_LOG 2>&1 &
+
+SERVER_PID=$!
+
+# Wait for server to be ready
+wait_for_server_ready --port "$PORT" --server-log "$SERVER_LOG" --server-pid "$SERVER_PID"
+
+pip install -q datasets pandas
+
+run_benchmark_serving \
+    --model "$MODEL" \
+    --port "$PORT" \
+    --backend vllm \
+    --input-len "$ISL" \
+    --output-len "$OSL" \
+    --random-range-ratio "$RANDOM_RANGE_RATIO" \
+    --num-prompts "$((CONC * 10))" \
+    --max-concurrency "$CONC" \
+    --result-filename "$RESULT_FILENAME" \
+    --result-dir /workspace/ \
+    --trust-remote-code
+
+# After throughput, run evaluation only if RUN_EVAL is true
+if [ "${RUN_EVAL}" = "true" ]; then
+    run_eval --framework lm-eval --port "$PORT"
+    append_lm_eval_summary
+fi
+
+# Stop GPU monitoring
+stop_gpu_monitor
+set +x

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/reconciliation.yaml

@@ -0,0 +1,19 @@
+source:
+  artifact_id: 8309942231
+  aggregate_sha256: eed429788dbc5bf88673838d5de29a6e6e8e74755e88ddd7b58b297c46a556ba
+  rows: 1
+normalized:
+  table: measurements.parquet
+  rows: 18
+mapping:
+  - source: mean_ttft
+    normalized: [ttft, mean]
+    conversion: none
+  - source: mean_tpot
+    normalized: [tpot, mean]
+    conversion: none
+  - source: tput_per_gpu
+    normalized: [throughput, mean]
+    conversion: none
+values_match: true
+units: Source latency seconds and throughput tokens/s/GPU are preserved.

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/requested-config.yaml

@@ -0,0 +1,24 @@
+source_config: dsv4-fp8-h200-vllm
+model: deepseek-ai/DeepSeek-V4-Pro
+model_revision: null
+hardware: H200
+framework: vllm
+framework_version: 0.25.1
+image: vllm/vllm-openai:v0.25.1
+precision: fp8
+input_tokens: 1024
+output_tokens: 1024
+concurrency: 16
+num_prompts: 160
+tensor_parallel_size: 8
+pipeline_parallel_size: 1
+data_parallel_size: 1
+expert_parallel_size: 1
+decode_context_parallel_size: 1
+prefill_context_parallel_size: 1
+dp_attention: false
+disaggregated: false
+speculative_decoding: none
+max_model_len_recipe_comment: 800000
+random_range_ratio: null
+image_digest: null

data/e2e/deepseek-ai--DeepSeek-V4-Pro/H200/vllm/0.25.1/tp8/provenance/inferencex-run-29316772188-attempt-1/source-aggregate.json

@@ -0,0 +1,56 @@
+{
+  "hw": "h200",
+  "conc": 16,
+  "image": "vllm/vllm-openai:v0.25.1",
+  "model": "deepseek-ai/DeepSeek-V4-Pro",
+  "infmax_model_prefix": "dsv4",
+  "framework": "vllm",
+  "precision": "fp8",
+  "spec_decoding": "none",
+  "disagg": false,
+  "isl": 1024,
+  "osl": 1024,
+  "is_multinode": false,
+  "tp": 8,
+  "pp": 1,
+  "dcp_size": 1,
+  "pcp_size": 1,
+  "ep": 1,
+  "dp_attention": "false",
+  "tput_per_gpu": 153.23358503172562,
+  "output_tput_per_gpu": 76.21114575220491,
+  "input_tput_per_gpu": 77.02243927952071,
+  "mean_ttft": 0.8870075593702496,
+  "median_ttft": 0.4869475280866027,
+  "std_ttft": 1.1276193665362704,
+  "p90_ttft": 0.9740721061825742,
+  "p99_ttft": 6.155770289283244,
+  "p99.9_ttft": 6.812136084629227,
+  "mean_tpot": 0.024853891183898143,
+  "mean_intvty": 40.235148395912375,
+  "median_tpot": 0.02521957511891945,
+  "median_intvty": 39.65173859133776,
+  "std_tpot": 0.0017310578877179242,
+  "std_intvty": 577.6814323166933,
+  "p90_tpot": 0.026219733964575737,
+  "p90_intvty": 38.139212295252634,
+  "p99_tpot": 0.027602960369130736,
+  "p99_intvty": 36.22799825189517,
+  "p99.9_tpot": 0.02823140630432796,
+  "p99.9_intvty": 35.42154397907897,
+  "mean_itl": 0.0248810343796077,
+  "median_itl": 0.018208758905529976,
+  "std_itl": 0.03659134149793887,
+  "p90_itl": 0.01898130588233471,
+  "p99_itl": 0.23019087258726356,
+  "p99.9_itl": 0.24195966927334667,
+  "mean_e2el": 23.65051023357082,
+  "median_e2el": 23.617231554351747,
+  "std_e2el": 2.5015721229827563,
+  "p90_e2el": 26.609794213995336,
+  "p99_e2el": 29.949763207361098,
+  "p99.9_e2el": 30.996576240185654,
+  "avg_power_w": 425.523,
+  "joules_per_output_token": 5.583476,
+  "joules_per_total_token": 2.776957
+}

dataset.yaml

@@ -0,0 +1,5 @@
+schema_version: dataset-catalog/v1
+name: nvidia/aisim-data
+license: Apache-2.0
+categories: [op-latency, e2e, fpm]
+catalogs: [data/catalog.yaml]

pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aisim-data-tools"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["jsonschema>=4.20", "PyYAML>=6.0"]
+
+[project.optional-dependencies]
+dev = ["pyarrow>=15", "pytest>=8", "zstandard>=0.22"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

schemas/common-v1.schema.yaml

@@ -0,0 +1,87 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: common-v1.schema.yaml
+title: AISimulate shared data types
+$defs:
+  sha256:
+    type: string
+    pattern: '^[0-9a-f]{64}$'
+  artifact:
+    type: object
+    additionalProperties: false
+    required: [id, path, role, format, sha256, bytes]
+    properties:
+      id: {type: string, pattern: '^[a-z0-9][a-z0-9._-]*$'}
+      path: {type: string, pattern: '^(?!/)(?!.*\.\.).+$'}
+      role: {type: string, minLength: 1}
+      format: {enum: [parquet, yaml, json, jsonl, csv, log.zst, shell]}
+      schema: {type: [string, 'null']}
+      sha256: {$ref: '#/$defs/sha256'}
+      bytes: {type: integer, minimum: 0}
+      rows: {type: integer, minimum: 0}
+      source_sha256: {$ref: '#/$defs/sha256'}
+      modified: {type: boolean}
+  identity:
+    type: object
+    additionalProperties: false
+    required: [hardware, framework, framework_version]
+    properties:
+      hardware: {type: string, minLength: 1}
+      framework: {type: string, minLength: 1}
+      framework_version: {type: string, minLength: 1}
+  model:
+    type: object
+    additionalProperties: false
+    required: [id, revision]
+    properties:
+      id: {type: string, pattern: '^[^/]+/[^/]+$'}
+      revision: {type: string, minLength: 1}
+  parallelism:
+    type: object
+    additionalProperties: false
+    required: [label, tp, pp, dp, ep]
+    properties:
+      label: {type: string, pattern: '^[a-z]+[0-9]+(?:-[a-z]+[0-9]+)*$'}
+      tp: {type: integer, minimum: 1}
+      pp: {type: integer, minimum: 1}
+      dp: {type: integer, minimum: 1}
+      ep: {type: integer, minimum: 1}
+      dcp: {type: integer, minimum: 1}
+      pcp: {type: integer, minimum: 1}
+      decode_context_parallel: {type: integer, minimum: 1}
+  runtime:
+    type: object
+    additionalProperties: false
+    required: [image, image_digest]
+    properties:
+      image: {type: string, minLength: 1}
+      image_digest:
+        oneOf:
+          - {type: string, pattern: '^sha256:[0-9a-f]{64}$'}
+          - {type: 'null'}
+      command: {type: string}
+  evidence_gap:
+    type: object
+    additionalProperties: false
+    required: [kind, status, reason]
+    properties:
+      kind: {type: string, minLength: 1}
+      status: {enum: [missing, failed, excluded, unavailable, pending]}
+      reason: {type: string, minLength: 1}
+      evidence: {type: string}
+  source:
+    type: object
+    additionalProperties: false
+    required: [project, url, revision, license, attribution, unofficial]
+    properties:
+      project: {type: string, minLength: 1}
+      url: {type: string, format: uri}
+      revision: {type: string, minLength: 7}
+      license: {type: string, minLength: 1}
+      attribution: {type: string, minLength: 1}
+      unofficial: {type: boolean}
+      workflow_url: {type: string, format: uri}
+      workflow_status: {type: string}
+      artifact_ids:
+        type: array
+        uniqueItems: true
+        items: {type: integer, minimum: 1}

schemas/e2e-manifest-v1.schema.yaml

@@ -0,0 +1,60 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: e2e-manifest-v1.schema.yaml
+title: E2E manifest v1
+type: object
+additionalProperties: false
+required: [schema_version, category, model, identity, precision, parallelism, deployment, runtime, workload, metrics, sources, artifacts, evidence_gaps]
+properties:
+  schema_version: {const: e2e-manifest/v1}
+  category: {const: e2e}
+  model: {$ref: common-v1.schema.yaml#/$defs/model}
+  identity: {$ref: common-v1.schema.yaml#/$defs/identity}
+  precision: {type: string, minLength: 1}
+  parallelism: {$ref: common-v1.schema.yaml#/$defs/parallelism}
+  deployment:
+    type: object
+    additionalProperties: false
+    required: [mode]
+    properties:
+      mode: {enum: [aggregated, disaggregated]}
+      prefill_workers: {type: integer, minimum: 0}
+      decode_workers: {type: integer, minimum: 0}
+  runtime: {$ref: common-v1.schema.yaml#/$defs/runtime}
+  workload:
+    type: object
+    additionalProperties: false
+    required: [input_tokens, output_tokens, concurrency, arrival_policy, warmup_requests, cache_state, requested_requests, completed_requests, failed_requests]
+    properties:
+      input_tokens: {type: integer, minimum: 0}
+      output_tokens: {type: integer, minimum: 0}
+      concurrency: {type: integer, minimum: 1}
+      arrival_policy: {type: string, minLength: 1}
+      warmup_requests: {type: integer, minimum: 0}
+      cache_state: {type: string, minLength: 1}
+      requested_requests: {type: integer, minimum: 0}
+      completed_requests: {type: [integer, 'null'], minimum: 0}
+      failed_requests: {type: [integer, 'null'], minimum: 0}
+  metrics:
+    type: array
+    minItems: 1
+    items:
+      type: object
+      additionalProperties: false
+      required: [name, value, unit, statistic, timing_boundary]
+      properties:
+        name: {enum: [ttft, tpot, itl, e2e_latency, throughput, input_throughput, output_throughput, error_rate, power, energy_per_output_token, energy_per_total_token]}
+        value: {type: number}
+        unit: {enum: [ms, s, requests/s, tokens/s/gpu, ratio, W, J/token]}
+        statistic: {enum: [mean, median, p50, p90, p95, p99, p99.9, total]}
+        timing_boundary: {type: string, minLength: 1}
+  sources:
+    type: array
+    minItems: 1
+    items: {$ref: common-v1.schema.yaml#/$defs/source}
+  artifacts:
+    type: array
+    minItems: 1
+    items: {$ref: common-v1.schema.yaml#/$defs/artifact}
+  evidence_gaps:
+    type: array
+    items: {$ref: common-v1.schema.yaml#/$defs/evidence_gap}

schemas/fpm-manifest-v1.schema.yaml

@@ -0,0 +1,31 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: fpm-manifest-v1.schema.yaml
+title: FPM manifest v1
+type: object
+additionalProperties: false
+required: [schema_version, category, model, identity, precision, parallelism, runtime, protocol, artifacts, evidence_gaps]
+properties:
+  schema_version: {const: fpm-manifest/v1}
+  category: {const: fpm}
+  model: {$ref: common-v1.schema.yaml#/$defs/model}
+  identity: {$ref: common-v1.schema.yaml#/$defs/identity}
+  precision: {type: string, minLength: 1}
+  parallelism: {$ref: common-v1.schema.yaml#/$defs/parallelism}
+  runtime: {$ref: common-v1.schema.yaml#/$defs/runtime}
+  protocol:
+    type: object
+    additionalProperties: false
+    required: [classification, phases, rank_aggregation, timing_boundary, measurement]
+    properties:
+      classification: {enum: [calibration, validation]}
+      phases: {type: array, minItems: 1, uniqueItems: true, items: {type: string}}
+      rank_aggregation: {type: string, minLength: 1}
+      timing_boundary: {type: string, minLength: 1}
+      measurement: {type: string, minLength: 1}
+  artifacts:
+    type: array
+    minItems: 1
+    items: {$ref: common-v1.schema.yaml#/$defs/artifact}
+  evidence_gaps:
+    type: array
+    items: {$ref: common-v1.schema.yaml#/$defs/evidence_gap}

schemas/gap-analysis-v1.schema.yaml

@@ -0,0 +1,49 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: gap-analysis-v1.schema.yaml
+title: AISimulate Replay gap analysis v1
+type: object
+additionalProperties: false
+required: [schema_version, engine, dataset, aisimulate, workload, results, reconciliation]
+properties:
+  schema_version: {const: gap-analysis/v1}
+  engine: {const: aisimulate-replay}
+  dataset:
+    type: object
+    additionalProperties: false
+    required: [revision, manifest_path]
+    properties:
+      revision: {type: string, minLength: 1}
+      manifest_path: {type: string, minLength: 1}
+  aisimulate:
+    type: object
+    additionalProperties: false
+    required: [revision]
+    properties: {revision: {type: string, minLength: 7}}
+  workload:
+    type: object
+    additionalProperties: true
+    required: [input_tokens, output_tokens, concurrency]
+  results:
+    type: array
+    minItems: 1
+    items:
+      type: object
+      additionalProperties: false
+      required: [metric, measured, predicted, unit, status]
+      properties:
+        metric: {enum: [ttft, tpot]}
+        measured: {type: number}
+        predicted: {type: [number, 'null']}
+        unit: {const: ms}
+        absolute_percentage_error: {type: [number, 'null'], minimum: 0}
+        status: {enum: [passed, failed, unsupported, pending]}
+        reason: {type: string}
+  reconciliation:
+    type: object
+    additionalProperties: false
+    required: [source_rows, normalized_rows, values_match, units]
+    properties:
+      source_rows: {type: integer, minimum: 0}
+      normalized_rows: {type: integer, minimum: 0}
+      values_match: {type: boolean}
+      units: {type: string, minLength: 1}

schemas/op-latency-manifest-v1.schema.yaml

@@ -0,0 +1,29 @@
+$schema: https://json-schema.org/draft/2020-12/schema
+$id: op-latency-manifest-v1.schema.yaml
+title: Operation-latency manifest v1
+type: object
+additionalProperties: false
+required: [schema_version, category, identity, operation_family, runtime, collection, artifacts, evidence_gaps]
+properties:
+  schema_version: {const: op-latency-manifest/v1}
+  category: {const: op-latency}
+  identity: {$ref: common-v1.schema.yaml#/$defs/identity}
+  operation_family: {type: string, minLength: 1}
+  runtime: {$ref: common-v1.schema.yaml#/$defs/runtime}
+  collection:
+    type: object
+    additionalProperties: false
+    required: [collector_revision, case_plan_sha256, collected_at, failures, exclusions]
+    properties:
+      collector_revision: {type: string, minLength: 7}
+      case_plan_sha256: {$ref: common-v1.schema.yaml#/$defs/sha256}
+      collected_at: {type: string, format: date-time}
+      failures: {type: array, items: {type: string}}
+      exclusions: {type: array, items: {type: string}}
+  artifacts:
+    type: array
+    minItems: 1
+    items: {$ref: common-v1.schema.yaml#/$defs/artifact}
+  evidence_gaps:
+    type: array
+    items: {$ref: common-v1.schema.yaml#/$defs/evidence_gap}

scripts/build_catalog.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+"""Build deterministic, non-authoritative indexes from leaf manifests."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data"
+
+
+def rendered_catalog() -> str:
+    entries = []
+    for path in sorted(DATA.glob("*/**/manifest.yaml")):
+        document = yaml.safe_load(path.read_text(encoding="utf-8"))
+        entries.append({"category": document["category"], "manifest": path.relative_to(ROOT).as_posix()})
+    return yaml.safe_dump({"generated": True, "entries": entries}, sort_keys=False)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true")
+    args = parser.parse_args()
+    target = DATA / "catalog.yaml"
+    expected = rendered_catalog()
+    if args.check:
+        if not target.exists() or target.read_text(encoding="utf-8") != expected:
+            print("data/catalog.yaml is stale; run scripts/build_catalog.py", file=sys.stderr)
+            return 1
+        return 0
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(expected, encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/validate.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+"""Validate manifests, artifact integrity, category paths, and generated catalogs."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import sys
+from pathlib import Path
+from typing import Any
+
+import jsonschema
+import yaml
+from referencing import Registry, Resource
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMAS = ROOT / "schemas"
+DATA = ROOT / "data"
+CATEGORY_DEPTH = {"op-latency": 4, "e2e": 5, "fpm": 5}
+
+
+def load_yaml(path: Path) -> Any:
+    with path.open(encoding="utf-8") as stream:
+        return yaml.safe_load(stream)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def schema_validator(category: str) -> jsonschema.Draft202012Validator:
+    filename = f"{category}-manifest-v1.schema.yaml"
+    schema = load_yaml(SCHEMAS / filename)
+    common = load_yaml(SCHEMAS / "common-v1.schema.yaml")
+    registry = Registry().with_resources(
+        [
+            (common["$id"], Resource.from_contents(common)),
+            ((SCHEMAS / common["$id"]).as_uri(), Resource.from_contents(common)),
+        ]
+    )
+    return jsonschema.Draft202012Validator(schema, registry=registry)
+
+
+def validate_hierarchy(manifest_path: Path, document: dict[str, Any]) -> list[str]:
+    errors: list[str] = []
+    relative = manifest_path.relative_to(DATA)
+    category = relative.parts[0]
+    expected = CATEGORY_DEPTH[category]
+    identity_parts = relative.parts[1:-1]
+    if len(identity_parts) != expected:
+        errors.append(f"expected {expected} identity components, got {len(identity_parts)}")
+        return errors
+
+    identity = document["identity"]
+    if category == "op-latency":
+        hardware, operation, framework, version = identity_parts
+        expected_values = (identity["hardware"], document["operation_family"], identity["framework"], identity["framework_version"])
+        if any(key in document for key in ("model", "parallelism")):
+            errors.append("operation-latency manifest contains model or parallelism identity")
+    else:
+        model, hardware, framework, version, parallelism = identity_parts
+        expected_values = (
+            document["model"]["id"].replace("/", "--"), identity["hardware"],
+            identity["framework"], identity["framework_version"], document["parallelism"]["label"],
+        )
+    if tuple(identity_parts) != expected_values:
+        errors.append(f"path identity {tuple(identity_parts)!r} != manifest identity {expected_values!r}")
+    return errors
+
+
+def validate_artifacts(leaf: Path, artifacts: list[dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    seen: set[str] = set()
+    for artifact in artifacts:
+        artifact_id = artifact["id"]
+        if artifact_id in seen:
+            errors.append(f"duplicate artifact id: {artifact_id}")
+        seen.add(artifact_id)
+        target = (leaf / artifact["path"]).resolve()
+        try:
+            target.relative_to(leaf.resolve())
+        except ValueError:
+            errors.append(f"unsafe artifact path: {artifact['path']}")
+            continue
+        if not target.is_file():
+            errors.append(f"missing artifact: {artifact['path']}")
+            continue
+        if target.stat().st_size != artifact["bytes"]:
+            errors.append(f"byte-size mismatch: {artifact['path']}")
+        if sha256(target) != artifact["sha256"]:
+            errors.append(f"SHA-256 mismatch: {artifact['path']}")
+        if artifact.get("format") == "parquet" and "rows" in artifact:
+            try:
+                import pyarrow.parquet as parquet
+
+                if parquet.read_metadata(target).num_rows != artifact["rows"]:
+                    errors.append(f"row-count mismatch: {artifact['path']}")
+            except ImportError:
+                pass
+    return errors
+
+
+def validate_manifest(path: Path) -> list[str]:
+    errors: list[str] = []
+    try:
+        document = load_yaml(path)
+        category = path.relative_to(DATA).parts[0]
+        if category not in CATEGORY_DEPTH:
+            return ["unknown category"]
+        for error in schema_validator(category).iter_errors(document):
+            location = ".".join(str(part) for part in error.absolute_path) or "<root>"
+            errors.append(f"schema {location}: {error.message}")
+        if errors:
+            return errors
+        errors.extend(validate_hierarchy(path, document))
+        errors.extend(validate_artifacts(path.parent, document["artifacts"]))
+        if any(source["project"].lower() == "inferencex" for source in document.get("sources", [])):
+            source = next(source for source in document["sources"] if source["project"].lower() == "inferencex")
+            if source["license"] != "Apache-2.0" or not source["unofficial"]:
+                errors.append("InferenceX source must declare Apache-2.0 and unofficial: true")
+    except (OSError, yaml.YAMLError, KeyError, TypeError) as error:
+        errors.append(str(error))
+    return errors
+
+
+def validate(root: Path = DATA) -> list[str]:
+    failures: list[str] = []
+    for manifest in sorted(root.glob("*/**/manifest.yaml")):
+        for error in validate_manifest(manifest):
+            failures.append(f"{manifest.relative_to(ROOT)}: {error}")
+    if not list(root.glob("*/**/manifest.yaml")):
+        failures.append("no manifests found")
+    gap_schema = load_yaml(SCHEMAS / "gap-analysis-v1.schema.yaml")
+    common = load_yaml(SCHEMAS / "common-v1.schema.yaml")
+    registry = Registry().with_resources(
+        [
+            (common["$id"], Resource.from_contents(common)),
+            ((SCHEMAS / common["$id"]).as_uri(), Resource.from_contents(common)),
+        ]
+    )
+    gap_validator = jsonschema.Draft202012Validator(gap_schema, registry=registry)
+    for gap in sorted(root.glob("e2e/**/evaluations/*/gap-analysis.yaml")):
+        for error in gap_validator.iter_errors(load_yaml(gap)):
+            failures.append(f"{gap.relative_to(ROOT)}: schema: {error.message}")
+    return failures
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=DATA)
+    args = parser.parse_args()
+    failures = validate(args.root)
+    if failures:
+        print("\n".join(failures), file=sys.stderr)
+        return 1
+    print("All manifests are valid.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tests/fixtures/invalid-e2e-manifest.yaml

@@ -0,0 +1,3 @@
+schema_version: e2e-manifest/v1
+category: e2e
+unexpected_field: rejected

tests/fixtures/valid-e2e-manifest.yaml

@@ -0,0 +1,16 @@
+schema_version: e2e-manifest/v1
+category: e2e
+model: {id: org/model, revision: abcdef0}
+identity: {hardware: H200, framework: vllm, framework_version: 1.0.0}
+precision: fp8
+parallelism: {label: tp1, tp: 1, pp: 1, dp: 1, ep: 1}
+deployment: {mode: aggregated}
+runtime: {image: example/image:1.0, image_digest: null}
+workload: {input_tokens: 1, output_tokens: 1, concurrency: 1, arrival_policy: closed-loop, warmup_requests: 0, cache_state: cold, requested_requests: 1, completed_requests: 1, failed_requests: 0}
+metrics:
+  - {name: ttft, value: 1, unit: ms, statistic: mean, timing_boundary: client}
+sources:
+  - {project: example, url: 'https://example.com', revision: abcdef0, license: Apache-2.0, attribution: example, unofficial: false}
+artifacts:
+  - {id: measurements, path: measurements.parquet, role: measurements, format: parquet, schema: e2e/v1, sha256: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bytes: 1, rows: 1}
+evidence_gaps: []

tests/test_validation.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+
+import yaml
+
+from scripts.validate import DATA, schema_validator, validate, validate_manifest
+
+
+FIXTURES = Path(__file__).parent / "fixtures"
+
+
+def test_repository_data_is_valid():
+    assert validate() == []
+
+
+def test_unknown_manifest_field_is_rejected(tmp_path: Path):
+    document = yaml.safe_load((FIXTURES / "invalid-e2e-manifest.yaml").read_text())
+    errors = list(schema_validator("e2e").iter_errors(document))
+    assert errors
+
+
+def test_valid_fixture_matches_schema():
+    document = yaml.safe_load((FIXTURES / "valid-e2e-manifest.yaml").read_text())
+    assert list(schema_validator("e2e").iter_errors(document)) == []
+
+
+def test_path_identity_is_enforced(tmp_path: Path):
+    source = next(DATA.glob("e2e/**/manifest.yaml"))
+    target = DATA / "e2e/deepseek-ai--DeepSeek-V4-Pro/H100/vllm/0.25.1/tp8/manifest.yaml"
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_bytes(source.read_bytes())
+    try:
+        assert any("path identity" in error for error in validate_manifest(target))
+    finally:
+        target.unlink()
+        for parent in [target.parent, target.parent.parent, target.parent.parent.parent, target.parent.parent.parent.parent]:
+            try:
+                parent.rmdir()
+            except OSError:
+                break