Prepare VibeThinker-3B J Lens model release

.gitattributes

@@ -0,0 +1,3 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+LICENSES/QWEN-RESEARCH.txt text eol=lf whitespace=-trailing-space

.gitignore

@@ -0,0 +1,36 @@
+# Public release allowlist. Add each new intended file explicitly.
+*
+
+!/.gitignore
+!/.gitattributes
+!/README.md
+!/NOTICE
+!/THIRD_PARTY_NOTICES.md
+!/SHA256SUMS
+!/model.safetensors
+!/evaluation.safetensors
+!/lens_config.json
+!/tensor_manifest.json
+!/evaluation_tensor_manifest.json
+!/provenance.json
+!/evaluation_provenance.json
+!/validation.json
+!/evaluation_validation.json
+!/evaluation.json
+!/evaluation_compatibility.json
+!/requirements.txt
+
+!/assets/
+!/assets/jlens-model-banner.png
+!/assets/two-lens-files.png
+!/assets/two-lens-files.svg
+
+!/LICENSES/
+!/LICENSES/APACHE-2.0.txt
+!/LICENSES/QWEN-RESEARCH.txt
+!/LICENSES/VIBETHINKER-LICENSE-NOTE.txt
+
+!/scripts/
+!/scripts/convert_checkpoint.py
+!/scripts/convert_evaluation_checkpoint.py
+!/scripts/validate_artifact.py

LICENSES/APACHE-2.0.txt

@@ -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 [yyyy] [name of copyright owner]
+
+   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.

LICENSES/QWEN-RESEARCH.txt

@@ -0,0 +1,54 @@
+Qwen RESEARCH LICENSE AGREEMENT
+
+Qwen RESEARCH LICENSE AGREEMENT Release Date: September 19, 2024
+
+By clicking to agree or by using or distributing any portion or element of the Qwen Materials, you will be deemed to have recognized and accepted the content of this Agreement, which is effective immediately.
+
+1. Definitions
+    a. This Qwen RESEARCH LICENSE AGREEMENT (this "Agreement") shall mean the terms and conditions for use, reproduction, distribution and modification of the Materials as defined by this Agreement.
+    b. "We" (or "Us") shall mean Alibaba Cloud.
+    c. "You" (or "Your") shall mean a natural person or legal entity exercising the rights granted by this Agreement and/or using the Materials for any purpose and in any field of use.
+    d. "Third Parties" shall mean individuals or legal entities that are not under common control with us or you.
+    e. "Qwen" shall mean the large language models, and software and algorithms, consisting of trained model weights, parameters (including optimizer states), machine-learning model code, inference-enabling code, training-enabling code, fine-tuning enabling code and other elements of the foregoing distributed by us.
+    f. "Materials" shall mean, collectively, Alibaba Cloud's proprietary Qwen and Documentation (and any portion thereof) made available under this Agreement.
+    g. "Source" form shall mean the preferred form for making modifications, including but not limited to model source code, documentation source, and configuration files.
+    h. "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.
+    i. "Non-Commercial" shall mean for research or evaluation purposes only.
+
+2. Grant of Rights
+    a. You are granted a non-exclusive, worldwide, non-transferable and royalty-free limited license under Alibaba Cloud's intellectual property or other rights owned by us embodied in the Materials to use, reproduce, distribute, copy, create derivative works of, and make modifications to the Materials FOR NON-COMMERCIAL PURPOSES ONLY. 
+    b. If you are commercially using the Materials, you shall request a license from us.
+
+3. Redistribution
+You may distribute copies or make the Materials, or derivative works thereof, available as part of a product or service that contains any of them, with or without modifications, and in Source or Object form, provided that you meet the following conditions:
+    a. You shall give any other recipients of the Materials or derivative works a copy of this Agreement;
+    b. You shall cause any modified files to carry prominent notices stating that you changed the files;
+    c. You shall retain in all copies of the Materials that you distribute the following attribution notices within a "Notice" text file distributed as a part of such copies: "Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c) Alibaba Cloud. All Rights Reserved."; and
+    d. 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 terms and conditions of this Agreement.
+
+4. Rules of use
+    a. The Materials may be subject to export controls or restrictions in China, the United States or other countries or regions. You shall comply with applicable laws and regulations in your use of the Materials.
+    b. If you use the Materials or any outputs or results therefrom to create, train, fine-tune, or improve an AI model that is distributed or made available, you shall prominently display “Built with Qwen” or “Improved using Qwen” in the related product documentation.
+
+5. Intellectual Property
+    a. We retain ownership of all intellectual property rights in and to the Materials and derivatives made by or for us. Conditioned upon compliance with the terms and conditions of this Agreement, with respect to any derivative works and modifications of the Materials that are made by you, you are and will be the owner of such derivative works and modifications.
+    b. No trademark license is granted to use the trade names, trademarks, service marks, or product names of us, except as required to fulfill notice requirements under this Agreement or as required for reasonable and customary use in describing and redistributing the Materials.
+    c. If you commence a lawsuit or other proceedings (including a cross-claim or counterclaim in a lawsuit) against us or any entity alleging that the Materials or any output therefrom, or any part of the foregoing, infringe any intellectual property or other right owned or licensable by you, then all licenses granted to you under this Agreement shall terminate as of the date such lawsuit or other proceeding is commenced or brought.
+
+6. Disclaimer of Warranty and Limitation of Liability
+    a. We are not obligated to support, update, provide training for, or develop any further version of the Qwen Materials or to grant any license thereto.
+    b. THE MATERIALS ARE PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED WARRANTY OF ANY KIND INCLUDING WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. WE MAKE NO WARRANTY AND ASSUME NO RESPONSIBILITY FOR THE SAFETY OR STABILITY OF THE MATERIALS AND ANY OUTPUT THEREFROM.
+    c. IN NO EVENT SHALL WE BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO ANY DIRECT, OR INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING FROM YOUR USE OR INABILITY TO USE THE MATERIALS OR ANY OUTPUT OF IT, NO MATTER HOW IT’S CAUSED.
+    d. You will defend, indemnify and hold harmless us from and against any claim by any third party arising out of or related to your use or distribution of the Materials.
+
+7. Survival and Termination.
+    a. The term of this Agreement shall commence upon your acceptance of this Agreement or access to the Materials and will continue in full force and effect until terminated in accordance with the terms and conditions herein.
+    b. We may terminate this Agreement if you breach any of the terms or conditions of this Agreement. Upon termination of this Agreement, you must delete and cease use of the Materials. Sections 6 and 8 shall survive the termination of this Agreement.
+
+8. Governing Law and Jurisdiction.
+    a. This Agreement and any dispute arising out of or relating to it will be governed by the laws of China, without regard to conflict of law principles, and the UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement.
+    b. The People's Courts in Hangzhou City shall have exclusive jurisdiction over any dispute arising out of this Agreement.
+
+9. Other Terms and Conditions.
+    a. Any arrangements, understandings, or agreements regarding the Material not stated herein are separate from and independent of the terms and conditions of this Agreement. You shall request a separate license from us, if you use the Materials in ways not expressly agreed to in this Agreement. 
+    b. We shall not be bound by any additional or different terms or conditions communicated by you unless expressly agreed.

LICENSES/VIBETHINKER-LICENSE-NOTE.txt

@@ -0,0 +1,21 @@
+VibeThinker-3B license metadata note
+
+Upstream repository: WeiboAI/VibeThinker-3B
+Pinned revision: 77bd2cced09193c8b9a59a32bd8577bbd1f3e01c
+Pinned revision URL:
+https://huggingface.co/WeiboAI/VibeThinker-3B/tree/77bd2cced09193c8b9a59a32bd8577bbd1f3e01c
+
+The README model-card metadata at this revision declares:
+
+license: mit
+
+The pinned repository tree does not contain a standalone LICENSE file or
+NOTICE file. It does not contain a standalone copyright notice that identifies
+a holder and year.
+
+This file records the upstream metadata and file inventory. It is not an
+upstream license text. This release does not assign a VibeThinker copyright
+holder or year.
+
+The Qwen Research License Agreement used for this distribution is included
+separately at LICENSES/QWEN-RESEARCH.txt.

NOTICE

@@ -0,0 +1,25 @@
+VibeThinker-3B Jacobian Lens
+
+This package contains a fitted average-Jacobian readout artifact derived from
+activations of WeiboAI/VibeThinker-3B. The upstream model card identifies
+Qwen/Qwen2.5-Coder-3B as its base model.
+
+Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c)
+Alibaba Cloud. All Rights Reserved.
+
+Built with Qwen.
+
+The pinned VibeThinker model-card metadata declares `license: mit`. The pinned
+repository tree contains no standalone LICENSE file, NOTICE file, or copyright
+notice that identifies a holder and year. The metadata record and pinned
+revision URL are in LICENSES/VIBETHINKER-LICENSE-NOTE.txt.
+
+Modification notice: model.safetensors is a derived Jacobian lens tensor
+artifact, not a copy of the upstream language-model weights. It was converted
+losslessly from the fitted PyTorch serialization to safetensors; every FP16
+tensor bit pattern was preserved. No VibeThinker or Qwen base-model weights are
+included in this repository.
+
+The lens was fit using Anthropic PBC's jacobian-lens reference implementation,
+licensed under the Apache License 2.0. The fitting corpus was sourced from
+WikiText-103; no source prompt text is redistributed here.

README.md

@@ -0,0 +1,322 @@
+---
+license: other
+license_name: qwen-research-license
+license_link: https://huggingface.co/JacobMolBio/vibethinker-3b-jlens-model/blob/main/LICENSES/QWEN-RESEARCH.txt
+tags:
+- vibethinker-3b
+- jacobian-lens
+- mechanistic-interpretability
+- interpretability
+- qwen2
+- safetensors
+---
+
+![Stacked VibeThinker-3B and J Lens title beside a folded black-layer sculpture divided by a cyan plane. The subtitle reads: Watch the model’s answer take shape, layer by layer. Weights, traces, code, and a viewer.](assets/jlens-model-banner.png)
+
+# VibeThinker-3B J Lens
+
+The J Lens is a Jacobian lens fitted to
+[`WeiboAI/VibeThinker-3B`](https://huggingface.co/WeiboAI/VibeThinker-3B/tree/77bd2cced09193c8b9a59a32bd8577bbd1f3e01c).
+Pick one of the 18 fitted source layers and a token position, and the lens
+decodes that residual-stream activation into a ranked list of vocabulary
+tokens. Following one position across layers shows how the decoded ranking
+changes on the way to the model's final output.
+
+The lens contains 18 matrices, one for each even-numbered source layer from 0
+through 34. Each matrix maps its source-layer residual-stream activation into
+layer-35 coordinates. VibeThinker-3B's final normalization and vocabulary
+projection produce the ranked token scores.
+
+This repository contains the fitted lens in two Safetensors precisions.
+`model.safetensors` is the FP16 lens used to capture the released traces.
+`evaluation.safetensors` is the FP32 lens used for the recorded readout
+evaluation. Casting each FP32 matrix to FP16 reproduces the FP16 file exactly;
+both are included so every published result stays paired with the tensor
+values that produced it.
+
+The companion trace repository contains six saved traces. Each trace pairs a
+prompt and its generated response with the top 12 decoded tokens at each
+captured position for the 18 source layers and the final model layer.
+
+## Choose a path
+
+| Goal | Use |
+|---|---|
+| Browse saved traces | Open the [static viewer](https://jvogan.github.io/vibethinker-3b-jlens). It reads released trace JSON in the browser; it does not download model weights or run inference. |
+| Run a new prompt locally | Use `scripts/render_slice.py` in the [source repository](https://github.com/jvogan/vibethinker-3b-jlens). It uses the pinned VibeThinker-3B base-model weights and `model.safetensors`, the FP16 J Lens. |
+| Load the released lens in Python | Use `model.safetensors`, the FP16 trace lens. |
+| Recalculate the recorded readout statistics | Use `evaluation.safetensors`, the FP32 evaluation lens, with the released rank rows and `scripts/recalculate_readout.py` in the trace repository. |
+
+## Companion repositories
+
+| Release component | Location |
+|---|---|
+| Source code and Pages source | [https://github.com/jvogan/vibethinker-3b-jlens](https://github.com/jvogan/vibethinker-3b-jlens) |
+| Captured trace dataset | [https://huggingface.co/datasets/JacobMolBio/vibethinker-3b-jlens-traces](https://huggingface.co/datasets/JacobMolBio/vibethinker-3b-jlens-traces) |
+| Static Pages site | [https://jvogan.github.io/vibethinker-3b-jlens](https://jvogan.github.io/vibethinker-3b-jlens) |
+| Hugging Face model repository ID | [JacobMolBio/vibethinker-3b-jlens-model](https://huggingface.co/JacobMolBio/vibethinker-3b-jlens-model) |
+
+## Artifact identity
+
+| Field | Trace artifact | Evaluation artifact |
+|---|---|---|
+| File | `model.safetensors` | `evaluation.safetensors` |
+| SHA-256 | `089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c` | `0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1` |
+| Size | 150,996,824 bytes | 301,991,904 bytes |
+| Dtype | FP16 | FP32 |
+| Role | Captured trace readouts | Recorded readout evaluation |
+
+[![Use model.safetensors for FP16 trace work and evaluation.safetensors for the recorded FP32 evaluation.](assets/two-lens-files.png)](assets/two-lens-files.svg)
+
+Both artifacts contain 18 matrices with shape 2,048 × 2,048. Their source
+layers are every even layer from 0 through 34, and their target layer is 35.
+The lens was fit on 1,000 prompts for model revision
+`77bd2cced09193c8b9a59a32bd8577bbd1f3e01c`. The revision binding was
+reconstructed from the Hub head after the fit;
+[`provenance.json`](provenance.json) records that binding and its limits.
+
+## Files
+
+- `model.safetensors` — the 18 losslessly reserialized FP16 lens matrices.
+- `evaluation.safetensors` — the 18 losslessly reserialized FP32 evaluation matrices.
+- `lens_config.json` — model binding, layer layout, fit parameters, and artifact ID.
+- `tensor_manifest.json` — shape, dtype, size, and raw-byte SHA-256 for every tensor.
+- `evaluation_tensor_manifest.json` — the corresponding FP32 tensor manifest.
+- `evaluation_provenance.json` — derivation and source-hash bindings.
+- `evaluation_compatibility.json` — the FP32-to-FP16 comparison for every layer.
+- `evaluation_validation.json` — the exact FP32 conversion checks.
+- `provenance.json` — fit, corpus, software, and conversion provenance.
+- `validation.json` — exhaustive source-to-safetensors comparison result.
+- `evaluation.json` — recorded readout-only evaluation and its scope.
+- `SHA256SUMS` — checksums for both Safetensors files.
+- `requirements.txt` — pinned packages for loading and validation.
+- `scripts/validate_artifact.py` — validates the artifact without pickle.
+- `scripts/convert_checkpoint.py` — reproducible checkpoint conversion for a user-provided source file.
+- `scripts/convert_evaluation_checkpoint.py` — reproducible FP32 conversion.
+- `LICENSES/QWEN-RESEARCH.txt` — complete distribution terms for the artifacts.
+- `NOTICE` and `THIRD_PARTY_NOTICES.md` — required attribution and license context.
+
+## Tensor layout
+
+The keys are `J.<source_layer>`:
+
+```text
+J.0, J.2, J.4, J.6, J.8, J.10, J.12, J.14, J.16,
+J.18, J.20, J.22, J.24, J.26, J.28, J.30, J.32, J.34
+```
+
+Each matrix maps the post-transformer-block residual at its source layer into
+the layer-35 residual basis. With row-major batches of residual vectors, the
+transport used by the reference implementation is:
+
+```python
+transported = residual.float() @ J.float().T
+logits = unembed(transported)
+```
+
+Both Safetensors headers contain the model ID and revision, source and target
+layers, width, prompt count, source-checkpoint hash, and key pattern.
+
+`requirements.txt` pins the runtime used to create and validate
+`evaluation.safetensors`. `provenance.json` records the earlier runtime used
+to convert `model.safetensors`.
+
+## Install and load
+
+The `jlens` Python package comes from the companion source repository. This
+repository contains the fitted tensors and the dependencies needed to inspect
+and validate them.
+
+From this repository checkout, install both parts:
+
+```bash
+export JLENS_CODE_REPO_URL="https://github.com/jvogan/vibethinker-3b-jlens"
+git clone "$JLENS_CODE_REPO_URL" ../vibethinker-3b-jlens
+python3 -m pip install -r requirements.txt
+python3 -m pip install ../vibethinker-3b-jlens
+```
+
+Load the local artifact:
+
+```python
+from jlens import JacobianLens
+
+lens = JacobianLens.load("model.safetensors")
+print(lens.source_layers)
+```
+
+Or load an immutable Hugging Face revision, setting `JLENS_MODEL_REVISION`
+to the model-repository commit recorded in the source repository's
+`release-manifest.json`:
+
+```bash
+export JLENS_MODEL_REPO_ID="JacobMolBio/vibethinker-3b-jlens-model"
+export JLENS_MODEL_REVISION="<commit from the source repository's release-manifest.json>"
+```
+
+```python
+import os
+
+from jlens import JacobianLens
+
+lens = JacobianLens.from_pretrained(
+    os.environ["JLENS_MODEL_REPO_ID"],
+    filename="model.safetensors",
+    revision=os.environ["JLENS_MODEL_REVISION"],
+)
+```
+
+To inspect tensors without the companion package, install `requirements.txt`
+and use Safetensors directly:
+
+```python
+from safetensors import safe_open
+
+with safe_open("model.safetensors", framework="pt", device="cpu") as handle:
+    metadata = handle.metadata()
+    jacobians = {
+        int(key.split(".", 1)[1]): handle.get_tensor(key).clone()
+        for key in handle.keys()
+    }
+
+assert metadata["model_revision"] == (
+    "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c"
+)
+assert sorted(jacobians) == list(range(0, 36, 2))
+```
+
+Load VibeThinker itself from the upstream repository at the exact bound
+revision; this repository does not include VibeThinker or Qwen weights:
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model_id = "WeiboAI/VibeThinker-3B"
+revision = "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c"
+tokenizer = AutoTokenizer.from_pretrained(model_id, revision=revision)
+model = AutoModelForCausalLM.from_pretrained(
+    model_id,
+    revision=revision,
+    dtype="auto",
+)
+```
+
+Review and accept the upstream terms before downloading or using the model.
+
+## Viewer and new-prompt compute
+
+The companion Pages site is a static viewer for captured trace JSON. It
+parses, filters, and renders those records in the browser; loading a local
+JSON file uses the browser's file reader and does not upload the file. The
+static site cannot analyze a new prompt. That requires the companion source
+package, this lens artifact, the pinned VibeThinker weights, and local Python
+compute.
+
+## Fit method
+
+The lens was fit with the Apache-2.0 Anthropic Jacobian Lens reference
+implementation at commit
+[`581d398613e5602a5af361e1c34d3a92ea82ba8e`](https://github.com/anthropics/jacobian-lens/tree/581d398613e5602a5af361e1c34d3a92ea82ba8e).
+For each fitted source layer, the estimator sums cotangents over valid causal
+targets at or after a source position, averages over valid source positions,
+and gives each prompt equal weight.
+
+- Hook point: post-transformer-block output residual
+- Source layers: every even layer from 0 through 34
+- Target layer: 35
+- Sequence cap: 128 tokens
+- Leading positions skipped: 16
+- Final position excluded from fitting
+- Dimension batch: 8
+- Fit runtime dtype: BF16
+- Trace artifact dtype: FP16
+- Evaluation artifact dtype: FP32
+- Fit manifest: 1,000 examples from WikiText-103 raw train, minimum 600
+  characters
+
+[`provenance.json`](provenance.json) records the fit manifest, a later local
+rematerialization of the prompt set, and the hash checks that bind them.
+Prompt text is not included in this repository.
+
+## Validation
+
+Validation checked the following for every tensor in both artifacts:
+
+- exact key set;
+- exact shape and each artifact's declared FP16 or FP32 dtype;
+- exact numerical equality with the recorded source checkpoint;
+- exact FP16 or FP32 bit-pattern equality;
+- exact raw tensor-byte SHA-256;
+- contiguity and full finiteness; and
+- a Safetensors header free of private source paths.
+
+All 18 tensors in each artifact passed, and zero values changed. The
+FP32-to-FP16 cast also matches `model.safetensors` exactly for all 18 layers.
+Recheck both artifacts with:
+
+```bash
+python3 scripts/validate_artifact.py
+```
+
+The validator verifies both file checksums, cross-file model and artifact
+bindings, header metadata, tensor shapes and hashes, license and notice files,
+and FP32-to-FP16 compatibility.
+
+## Evaluation
+
+The recorded evaluation measures ranked-token readouts: for each prompt in a
+551-item suite, does a known target term rank highly in the decoded tokens?
+The paired token-target and shuffled-layer mapping checks passed for the
+selected band at layers 24, 26, 28, 30, 32, and 34. The comparison with the
+ordinary logit lens did not establish improvement.
+[`evaluation.json`](evaluation.json) records this readout-only scope as
+`validated_readout_only`.
+
+The 551 items cover association, multihop, multilingual,
+order-of-operations, poetry, and typo prompts, each pairing a prompt with one
+or more target terms. A deterministic split assigned 377 eligible items to
+the test set; the band was selected on development items. The companion trace
+repository contains all evaluation inputs, the 50,050 readout rows, the
+aggregate metrics, the bootstrap intervals, and the exact method, and its
+`scripts/recalculate_readout.py` recomputes every recorded statistic from the
+released rows. Regenerating the rows themselves requires the pinned base
+model, `evaluation.safetensors`, and a separate evaluator implementation.
+
+The recorded metrics bind to `evaluation.safetensors`
+(SHA-256 `0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1`,
+from source FP32 checkpoint SHA-256
+`8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9`);
+they do not evaluate `model.safetensors`. The evaluation does not measure
+general model accuracy or test causal steering or free-generation behavior.
+
+The lens is stride-2, was fit on 1,000 prompts, and is model-revision
+specific. Single-cell readouts can be noisy; compare patterns across nearby
+layers and positions before interpreting an isolated token.
+
+## License and attribution
+
+The Qwen Research License applies to this distribution and limits use to
+non-commercial research and evaluation. Commercial use requires a separate
+license from the upstream rights holder. Redistribution must include the
+complete [Qwen Research License](LICENSES/QWEN-RESEARCH.txt) and retain the
+required notice in [`NOTICE`](NOTICE). Built with Qwen. No VibeThinker or
+Qwen base-model weights are redistributed here.
+
+The pinned VibeThinker model-card metadata declares `license: mit` and names
+`Qwen/Qwen2.5-Coder-3B` as its base model; the pinned tree contains no
+standalone license file.
+[`LICENSES/VIBETHINKER-LICENSE-NOTE.txt`](LICENSES/VIBETHINKER-LICENSE-NOTE.txt)
+records that metadata and the pinned revision URL.
+
+The fitting implementation is Anthropic's Apache-2.0
+[`jacobian-lens`](https://github.com/anthropics/jacobian-lens). WikiText-103
+is available under CC BY-SA 4.0; no source text is redistributed here. See
+[`THIRD_PARTY_NOTICES.md`](THIRD_PARTY_NOTICES.md) for details and links.
+
+## References
+
+- Anthropic, [*Verbalizable Representations Form a Global Workspace in Language Models*](https://transformer-circuits.pub/2026/workspace/index.html)
+- Anthropic, [`jacobian-lens`](https://github.com/anthropics/jacobian-lens)
+- [`WeiboAI/VibeThinker-3B`](https://huggingface.co/WeiboAI/VibeThinker-3B/tree/77bd2cced09193c8b9a59a32bd8577bbd1f3e01c)
+- [`Qwen/Qwen2.5-Coder-3B`](https://huggingface.co/Qwen/Qwen2.5-Coder-3B)
+- [`Salesforce/wikitext`](https://huggingface.co/datasets/Salesforce/wikitext)

SHA256SUMS

@@ -0,0 +1,2 @@
+089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c  model.safetensors
+0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1  evaluation.safetensors

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,53 @@
+# Third-party notices
+
+This document records upstream materials associated with the artifact. It does
+not replace their license texts or expand the rights they grant.
+
+## VibeThinker-3B and Qwen2.5-Coder-3B
+
+The lens was fit from activations of
+[`WeiboAI/VibeThinker-3B`](https://huggingface.co/WeiboAI/VibeThinker-3B/tree/77bd2cced09193c8b9a59a32bd8577bbd1f3e01c), bound
+for reproducibility to revision
+`77bd2cced09193c8b9a59a32bd8577bbd1f3e01c`. The VibeThinker card identifies
+[`Qwen/Qwen2.5-Coder-3B`](https://huggingface.co/Qwen/Qwen2.5-Coder-3B) as its
+base model.
+
+The pinned VibeThinker model-card metadata declares `license: mit`. The pinned
+tree contains no standalone LICENSE file, NOTICE file, or copyright notice
+that identifies a holder and year.
+[`LICENSES/VIBETHINKER-LICENSE-NOTE.txt`](LICENSES/VIBETHINKER-LICENSE-NOTE.txt)
+records the declaration, pinned revision, and file-availability boundary. It
+is not an upstream license text.
+
+The Qwen base model is subject to the Qwen Research License. This repository
+therefore uses `license: other` and applies the non-commercial
+research/evaluation restriction. The complete Qwen terms are included at
+[`LICENSES/QWEN-RESEARCH.txt`](LICENSES/QWEN-RESEARCH.txt).
+
+Required notice:
+
+> Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, Copyright (c)
+> Alibaba Cloud. All Rights Reserved.
+
+Built with Qwen.
+
+No upstream VibeThinker or Qwen model weights are included.
+
+## Anthropic Jacobian Lens
+
+The artifact was fit using Anthropic PBC's
+[`jacobian-lens`](https://github.com/anthropics/jacobian-lens) reference
+implementation at commit
+`581d398613e5602a5af361e1c34d3a92ea82ba8e`.
+
+Copyright 2026 Anthropic PBC. Licensed under the Apache License, Version 2.0.
+The full license is included at
+[`LICENSES/APACHE-2.0.txt`](LICENSES/APACHE-2.0.txt).
+
+## WikiText-103
+
+The fitting corpus was selected from the WikiText-103 raw train split in
+[`Salesforce/wikitext`](https://huggingface.co/datasets/Salesforce/wikitext).
+The dataset card states that WikiText is available under the Creative Commons
+Attribution-ShareAlike 4.0 license. This repository records only corpus
+provenance and cryptographic digests; it does not redistribute the prompt text.

evaluation.json

@@ -0,0 +1,144 @@
+{
+  "artifact_kind": "frozen_vibethinker_v1_readout_reference",
+  "claim_boundary": "This reference records the V1 readout results. It excludes causal-assay results and does not establish free-generation steering or a global workspace.",
+  "classification": "validated_readout_only",
+  "coverage": {
+    "locked_test_items": 377,
+    "readout_items_completed": 539,
+    "readout_items_no_eligible_targets": 12,
+    "released_prompts": 551
+  },
+  "coverage_scope": "frozen_readout_source_run_not_the_100_prompt_ui_test_pack",
+  "task_definition": {
+    "aggregate_mean_reciprocal_rank": "mean_across_eligible_target_terms_of_reciprocal_best_rank",
+    "eligible_target": "at_least_one_candidate_form_tokenizes_to_exactly_one_token",
+    "final_model": "rank_target_terms_in_the_model_next_token_logits_at_the_score_position",
+    "item": "one_prompt_with_one_or_more_target_terms",
+    "layer_scope_reduction": "best_target_rank_across_layers_in_the_reported_scope",
+    "no_eligible_target_item": "none_of_the_item_target_terms_has_an_eligible_single_token_form",
+    "paired_bootstrap_mean_reciprocal_rank": "within_item_mean_of_reciprocal_best_rank_across_eligible_target_terms",
+    "pass_at_k": "mean_across_items_of_the_fraction_of_item_target_terms_with_best_rank_at_most_k",
+    "score_position": {
+      "default": "final_prompt_token",
+      "poetry": "last_newline_token"
+    },
+    "split": {
+      "dev_fraction": 0.3,
+      "method": "sha256_stable_split",
+      "seed": "vibethinker-jlens-v1"
+    },
+    "suites": ["association", "multihop", "multilingual", "order-ops", "poetry", "typo"],
+    "target_candidate_forms": [
+      "original_lowercase_and_capitalized_forms_with_and_without_leading_space",
+      "order_ops_also_adds_configured_operation_synonyms_and_number_word_digit_forms"
+    ],
+    "target_rank": "best_one_based_vocabulary_rank_among_eligible_target_token_ids"
+  },
+  "evidence": {
+    "incremental_over_ordinary_logit_lens": false,
+    "layer_mapping_specific_vs_shuffled_jacobian": true,
+    "paired_bootstrap": {
+      "confidence": 0.95,
+      "input": "paired_item_metric_differences",
+      "interval": "percentile",
+      "metrics": ["pass@10", "mean_reciprocal_rank"],
+      "samples": 2000,
+      "scope": {
+        "kind": "selected_band",
+        "source_layers": [24, 26, 28, 30, 32, 34]
+      },
+      "split": "test"
+    },
+    "paired_bootstrap_decisions": {
+      "incremental_over_ordinary_logit_lens": {
+        "comparison": "jlens_band_minus_logit_lens_band",
+        "criterion": "at_least_one_lower_bound_greater_than_zero",
+        "met": false
+      },
+      "layer_mapping_specific_vs_shuffled_jacobian": {
+        "comparison": "jlens_band_minus_shuffled_layer_band",
+        "criterion": "both_lower_bounds_greater_than_zero",
+        "met": true
+      },
+      "token_specific_vs_shuffled_target": {
+        "comparison": "jlens_band_minus_shuffled_token_band",
+        "criterion": "both_lower_bounds_greater_than_zero",
+        "met": true
+      }
+    },
+    "specificity_scope": {
+      "kind": "selected_band",
+      "source_layers": [24, 26, 28, 30, 32, 34]
+    },
+    "token_specific_vs_shuffled_target": true,
+    "validated_readout_signal": true
+  },
+  "lens_sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9",
+  "lens_variant": "fp32_evaluation_safetensors_included",
+  "released_lens_artifact": {
+    "filename": "evaluation.safetensors",
+    "format": "safetensors",
+    "sha256": "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1",
+    "size_bytes": 301991904,
+    "source_checkpoint_sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9",
+    "tensor_conversion": "lossless_fp32_reserialization"
+  },
+  "source_artifact_availability": {
+    "fp32_compatibility_check_output_included": true,
+    "fp32_compatibility_check_output_path": "evaluation_compatibility.json",
+    "fp32_derivation_record_included": true,
+    "fp32_derivation_record_path": "evaluation_provenance.json",
+    "fp32_evaluation_lens_included": true,
+    "fp32_evaluation_lens_path": "evaluation.safetensors",
+    "item_level_evaluation_rows_included": false,
+    "item_level_evaluation_rows_location": "companion_trace_repository:data/evaluation-results/readout-trials.jsonl",
+    "paired_bootstrap_interval_bounds_included": false,
+    "paired_bootstrap_interval_bounds_location": "companion_trace_repository:data/evaluation-results/readout-bootstrap-intervals.json",
+    "source_evaluation_bundle_included": false,
+    "source_hashes_included": true,
+    "source_hashes_location": "evaluation_provenance.json_and_companion_trace_repository:data/readout-reference.json",
+    "release_content": "fp16_trace_lens_fp32_evaluation_lens_aggregate_reference_provenance_and_compatibility"
+  },
+  "metrics": {
+    "jlens_all_layers": {
+      "mean_reciprocal_rank": 0.027840488103301416,
+      "n_items": 377,
+      "pass_at_1": 0.009283819628647215,
+      "pass_at_10": 0.08819628647214854,
+      "pass_at_50": 0.1655614500442087
+    },
+    "jlens_selected_band": {
+      "mean_reciprocal_rank": 0.01888596779741093,
+      "n_items": 377,
+      "pass_at_1": 0.003978779840848806,
+      "pass_at_10": 0.0629973474801061,
+      "pass_at_50": 0.11914235190097258
+    },
+    "logit_lens_all_layers": {
+      "mean_reciprocal_rank": 0.027249274540932285,
+      "n_items": 377,
+      "pass_at_1": 0.007294429708222812,
+      "pass_at_10": 0.08377541998231654,
+      "pass_at_50": 0.16114058355437666
+    },
+    "shuffled_layer_all_layers": {
+      "mean_reciprocal_rank": 0.042073366910739256,
+      "n_items": 377,
+      "pass_at_1": 0.04509283819628647,
+      "pass_at_10": 0.08819628647214854,
+      "pass_at_50": 0.1823607427055703
+    },
+    "final_model": {
+      "mean_reciprocal_rank": 0.019635164837169684,
+      "n_items": 377,
+      "pass_at_1": 0.003978779840848806,
+      "pass_at_10": 0.0665340406719717,
+      "pass_at_50": 0.10587975243147656
+    }
+  },
+  "model": "WeiboAI/VibeThinker-3B",
+  "model_revision": "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c",
+  "note": "The recorded readout metrics bind to evaluation.safetensors, the FP32 evaluation lens in this repository. They do not evaluate model.safetensors, the FP16 lens used for the captured traces.",
+  "selected_band": [24, 26, 28, 30, 32, 34],
+  "schema_version": 1
+}

evaluation.safetensors

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

evaluation_compatibility.json

@@ -0,0 +1,105 @@
+{
+  "all_layer_casts_match_exactly": true,
+  "artifact_kind": "fp32_to_fp16_lens_compatibility",
+  "conversion": "IEEE_FP32_to_FP16_round_to_nearest_even",
+  "fp16_artifact": "model.safetensors",
+  "fp16_artifact_sha256": "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c",
+  "fp32_artifact": "evaluation.safetensors",
+  "fp32_artifact_sha256": "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1",
+  "fp32_source_checkpoint_sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9",
+  "max_absolute_error": 0.00048828125,
+  "per_layer": {
+    "0": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00037920475006103516,
+      "relative_frobenius_error": 0.000206997521647552
+    },
+    "10": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0002696514129638672,
+      "relative_frobenius_error": 0.00020761765345058065
+    },
+    "12": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00046837329864501953,
+      "relative_frobenius_error": 0.00020767621517046658
+    },
+    "14": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00048673152923583984,
+      "relative_frobenius_error": 0.00020743575797500317
+    },
+    "16": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004863739013671875,
+      "relative_frobenius_error": 0.00020778469258608042
+    },
+    "18": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004839897155761719,
+      "relative_frobenius_error": 0.00020779679841448286
+    },
+    "2": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004121065139770508,
+      "relative_frobenius_error": 0.00020722711230071437
+    },
+    "20": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004881620407104492,
+      "relative_frobenius_error": 0.00020744978906595194
+    },
+    "22": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004878044128417969,
+      "relative_frobenius_error": 0.00020796356930850946
+    },
+    "24": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004870891571044922,
+      "relative_frobenius_error": 0.00020680286914392338
+    },
+    "26": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004875659942626953,
+      "relative_frobenius_error": 0.00020638797987813289
+    },
+    "28": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.0004818439483642578,
+      "relative_frobenius_error": 0.00020315668925901246
+    },
+    "30": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00048804283142089844,
+      "relative_frobenius_error": 0.000219304047701117
+    },
+    "32": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00048828125,
+      "relative_frobenius_error": 0.0002275111331836927
+    },
+    "34": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00048804283142089844,
+      "relative_frobenius_error": 0.00025735070181156144
+    },
+    "4": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.000270843505859375,
+      "relative_frobenius_error": 0.00020699111471641674
+    },
+    "6": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00024312734603881836,
+      "relative_frobenius_error": 0.00020716959804749024
+    },
+    "8": {
+      "cast_matches_model_safetensors_exactly": true,
+      "max_absolute_error": 0.00040781497955322266,
+      "relative_frobenius_error": 0.00020697079418794512
+    }
+  },
+  "relative_frobenius_error": 0.00020901276774552775,
+  "schema_version": 1
+}

evaluation_provenance.json

@@ -0,0 +1,90 @@
+{
+  "artifact": {
+    "filename": "evaluation.safetensors",
+    "format": "safetensors",
+    "sha256": "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1",
+    "size_bytes": 301991904,
+    "tensor_conversion": "lossless_fp32_reserialization"
+  },
+  "artifact_kind": "jacobian_lens_evaluation_fp32_provenance",
+  "compatibility": {
+    "all_layer_casts_match_exactly": true,
+    "file": "evaluation_compatibility.json",
+    "fp16_artifact": "model.safetensors",
+    "fp16_artifact_sha256": "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c"
+  },
+  "derivation": {
+    "formula": "jacobian_sum[layer] / n_done",
+    "n_done": 1000,
+    "source_export_script_sha256": "d1d9e0b7afd1d69771907a839f62b30936995fdd63b17ea2ac80f724b3cdce17",
+    "source_fit_checkpoint_sha256": "a1236cfe5d04601575b3de150ffe50e3a67e755ede1197ecf74c205a31bdc258",
+    "source_matrix_stats_sha256": "a21fe7c1f661fa9b5455d89c0a415beae794012eab38f782b667b27fac942401",
+    "source_provenance_sha256": "b6e5764fa1580a142403a425ecd03cafe55d4cc36ca1e6b90da7fc19a35aad36",
+    "source_validation_sha256": "4aea71008a10ef2d043129f7767e5d387372fe1fd5022550b59017a44e0b965d"
+  },
+  "lens": {
+    "d_model": 2048,
+    "dtype": "float32",
+    "estimator": {
+      "dim_batch": 8,
+      "exclude_final_position": true,
+      "fit_dtype": "bfloat16",
+      "max_seq_len": 128,
+      "name": "causal_all_current_and_future_targets_mean_jacobian",
+      "prompt_aggregation": "equal_weight_mean_over_prompts",
+      "skip_first": 16,
+      "source_position_aggregation": "mean_over_valid_source_positions",
+      "target_position_aggregation": "sum_over_valid_targets_at_or_after_source"
+    },
+    "hook_convention": "post_transformer_block_output_residual",
+    "n_prompts": 1000,
+    "source_layers": [
+      0,
+      2,
+      4,
+      6,
+      8,
+      10,
+      12,
+      14,
+      16,
+      18,
+      20,
+      22,
+      24,
+      26,
+      28,
+      30,
+      32,
+      34
+    ],
+    "target_layer": 35
+  },
+  "limitations": [
+    "The original fit did not store the resolved Hugging Face commit; the revision binding was reconstructed from the Hub head and its last-modified timestamp.",
+    "The recorded evaluation validates token readout and does not establish causal steering or a global workspace."
+  ],
+  "model": {
+    "architecture": "Qwen2ForCausalLM",
+    "d_model": 2048,
+    "id": "WeiboAI/VibeThinker-3B",
+    "n_layers": 36,
+    "revision": "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c",
+    "revision_binding": "inferred_hub_head_unchanged_since_before_fit",
+    "revision_last_modified": "2026-06-30T11:35:41+00:00",
+    "tied_embeddings": true
+  },
+  "schema_version": 1,
+  "software": {
+    "anthropic_jacobian_lens_commit": "581d398613e5602a5af361e1c34d3a92ea82ba8e",
+    "conversion_runtime": {
+      "python_implementation": "CPython",
+      "safetensors": "0.8.0",
+      "torch": "2.13.0"
+    }
+  },
+  "source_checkpoint": {
+    "format": "pytorch",
+    "sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9"
+  }
+}

evaluation_tensor_manifest.json

@@ -0,0 +1,209 @@
+{
+  "artifact": "evaluation.safetensors",
+  "artifact_sha256": "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1",
+  "artifact_size_bytes": 301991904,
+  "schema_version": 1,
+  "source_checkpoint_sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9",
+  "tensor_count": 18,
+  "tensor_storage_bytes": 301989888,
+  "tensors": {
+    "J.0": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "4a77bed8711fd26317619e7265da5c9ce73aadd2d4851800715c8c5ec6012c6e",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 0
+    },
+    "J.10": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "e2856885c149fa8244e327369c3bb081cfe651e1a6958bda317f8691e2db3c3b",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 10
+    },
+    "J.12": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "e6a50d9c6495acebeac769533bd6900ce94443fc977506f836881e5dcb0335a0",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 12
+    },
+    "J.14": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "b27ade6bee39486cad9b0cdf091f0690528509b0f4936d67e30ce3dc6eeeb6b8",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 14
+    },
+    "J.16": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "e80280578bd50abdb0c1610d453eb11495be80a8580fe8f490ff63d6ab1e2e1b",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 16
+    },
+    "J.18": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "23a2a10e7961625232b257e0943ad10893a9e2e051bf65b9f3e57778e293397f",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 18
+    },
+    "J.2": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "f90ad9dae2c7b8701cc5b6623ddb0a77cb072c5b95a8a45fff1eca8680e796e3",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 2
+    },
+    "J.20": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "c927effa01101f88b8c06023db5b9f727416ffde7f40be1515d48fa8215389cf",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 20
+    },
+    "J.22": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "bb319fcc2484b93bc7a7754e508e807cfcd5387474ad7fb97c786da57b22aeea",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 22
+    },
+    "J.24": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "a34fb656e93ee78c27bb88b42895aa11ecfc525d790ef54b1a18f72b7cf583e7",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 24
+    },
+    "J.26": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "1865fccec5a832ca6b0766324bd078d5ea12e2715c7d25664dfd56da8cd82b21",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 26
+    },
+    "J.28": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "9022027a77af3525b4c602723fedbd3871ffc0b4cf812081cdf6739ffb0f778b",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 28
+    },
+    "J.30": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "ed63bd90333f5feb4441f1887bef102e3c5b95776a6f9c3c88a657ba1a92845f",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 30
+    },
+    "J.32": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "c16a4dc0bd1af68302094d81cc898fa7fa30dca7f6ca0397f765c2b470716852",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 32
+    },
+    "J.34": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "92c6ab150ddf0ece4eeb3a9998d9a87a9d8fabbfdad35f15b18f27a80153ecc5",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 34
+    },
+    "J.4": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "59beda69c9baf4392cc55731fda3e3527c79948651fe9f38a9ce21669fe2aefa",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 4
+    },
+    "J.6": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "faca3b5a874af143d133a705ca92d8bcbb71fe862f17559464d11d9bf3a5015c",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 6
+    },
+    "J.8": {
+      "dtype": "float32",
+      "nbytes": 16777216,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "2e9e5f1d2773f627ed231a0c5a6697077761354574350a63ad82035540a1944b",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 8
+    }
+  }
+}

evaluation_validation.json

@@ -0,0 +1,29 @@
+{
+  "artifact": "evaluation.safetensors",
+  "artifact_sha256": "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1",
+  "artifact_size_bytes": 301991904,
+  "checks": {
+    "all_source_tensors_contiguous": true,
+    "all_source_tensors_finite": true,
+    "all_source_tensors_fp32": true,
+    "all_source_tensors_shape_2048x2048": true,
+    "fp16_cast_matches_companion_artifact": true,
+    "roundtrip_all_tensor_bit_patterns_equal": true,
+    "roundtrip_all_tensor_byte_hashes_equal": true,
+    "roundtrip_all_tensor_dtypes_equal": true,
+    "roundtrip_all_tensor_shapes_equal": true,
+    "roundtrip_all_tensor_values_equal": true,
+    "roundtrip_key_set_exact": true,
+    "safetensors_header_public_safe": true,
+    "safetensors_header_roundtrip_exact": true,
+    "source_checkpoint_sha256_exact": true,
+    "source_metadata_exact": true,
+    "source_top_level_key_set_exact": true
+  },
+  "exact_tensor_matches": 18,
+  "expected_tensor_matches": 18,
+  "ok": true,
+  "schema_version": 1,
+  "source_checkpoint_sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9",
+  "tensor_values_changed": 0
+}

lens_config.json

@@ -0,0 +1,62 @@
+{
+  "artifact": {
+    "filename": "model.safetensors",
+    "format": "safetensors",
+    "sha256": "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c",
+    "size_bytes": 150996824
+  },
+  "artifact_kind": "jacobian_lens",
+  "evaluation_artifact": {
+    "filename": "evaluation.safetensors",
+    "format": "safetensors",
+    "sha256": "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1",
+    "size_bytes": 301991904,
+    "source_checkpoint_sha256": "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9",
+    "tensor_conversion": "lossless_fp32_reserialization",
+    "tensor_dtype": "float32"
+  },
+  "d_model": 2048,
+  "fit": {
+    "dim_batch": 8,
+    "exclude_final_position": true,
+    "fit_dtype": "bfloat16",
+    "max_seq_len": 128,
+    "n_prompts": 1000,
+    "skip_first": 16
+  },
+  "model": {
+    "architecture": "Qwen2ForCausalLM",
+    "id": "WeiboAI/VibeThinker-3B",
+    "n_layers": 36,
+    "revision": "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c"
+  },
+  "n_prompts": 1000,
+  "schema_version": 1,
+  "source_checkpoint": {
+    "format": "pytorch",
+    "sha256": "f36a99447623e0d777c70951a9148a7a52e42e0df82942e22ce6326f63d8d664"
+  },
+  "source_layers": [
+    0,
+    2,
+    4,
+    6,
+    8,
+    10,
+    12,
+    14,
+    16,
+    18,
+    20,
+    22,
+    24,
+    26,
+    28,
+    30,
+    32,
+    34
+  ],
+  "target_layer": 35,
+  "tensor_dtype": "float16",
+  "tensor_key_pattern": "J.{source_layer}"
+}

model.safetensors

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

provenance.json

@@ -0,0 +1,128 @@
+{
+  "artifact": {
+    "filename": "model.safetensors",
+    "format": "safetensors",
+    "sha256": "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c",
+    "size_bytes": 150996824,
+    "tensor_conversion": "lossless_fp16_reserialization"
+  },
+  "artifact_kind": "jacobian_lens_provenance",
+  "conversion": {
+    "safetensors": "0.7.0",
+    "source_and_output_tensor_bit_patterns_equal": true,
+    "source_and_output_tensor_dtypes_equal": true,
+    "source_and_output_tensor_keys_equal": true,
+    "source_and_output_tensor_shapes_equal": true,
+    "torch": "2.12.0"
+  },
+  "fit": {
+    "d_model": 2048,
+    "dim_batch": 8,
+    "fit_date": null,
+    "fit_date_available": false,
+    "estimator": {
+      "exclude_final_position": true,
+      "name": "causal_all_current_and_future_targets_mean_jacobian",
+      "prompt_aggregation": "equal_weight_mean_over_prompts",
+      "source_position_aggregation": "mean_over_valid_source_positions",
+      "target_position_aggregation": "sum_over_valid_targets_at_or_after_source"
+    },
+    "fit_dtype": "bfloat16",
+    "hook_convention": "post_transformer_block_output_residual",
+    "max_seq_len": 128,
+    "n_prompts": 1000,
+    "skip_first": 16,
+    "source_layers": [
+      0,
+      2,
+      4,
+      6,
+      8,
+      10,
+      12,
+      14,
+      16,
+      18,
+      20,
+      22,
+      24,
+      26,
+      28,
+      30,
+      32,
+      34
+    ],
+    "stored_dtype": "float16",
+    "target_layer": 35
+  },
+  "limitations": [
+    "The original fit did not persist the resolved Hugging Face commit. The revision binding was reconstructed from the Hub head and its last-modified timestamp after the fit.",
+    "Artifact integrity and provenance do not establish causal intervention validity.",
+    "The fitting prompt text is not redistributed in this repository.",
+    "The original remote prompt JSONL is absent from the fetched fit artifacts. A later local materialization matches the remote manifest's aggregate row-hash chain and summary fields, but exact remote JSONL byte identity was not verified."
+  ],
+  "model": {
+    "architecture": "Qwen2ForCausalLM",
+    "d_model": 2048,
+    "id": "WeiboAI/VibeThinker-3B",
+    "n_layers": 36,
+    "revision": "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c",
+    "revision_binding": "inferred_hub_head_unchanged_since_before_fit",
+    "revision_last_modified": "2026-06-30T11:35:41+00:00",
+    "tied_embeddings": true
+  },
+  "prompt_corpus": {
+    "dataset": "Salesforce/wikitext",
+    "dataset_config": "wikitext-103-raw-v1",
+    "dataset_revision": null,
+    "fit_manifest": {
+      "first_id": "wikitext-0000",
+      "last_id": "wikitext-0999",
+      "manifest_sha256": "96593961cce7f84f72698cddfe67f2c0d2ea334083d93ca56aaa150ad42923c2",
+      "min_chars": 600,
+      "n_prompts": 1000,
+      "prompt_sha256_chain": "d49717ca76e73c570e18d0229c735e7049d636b7d5fdf3cc371e4877351cf368",
+      "prompt_sha256_chain_algorithm": "sha256(concatenated_per_row_sha256_hex)",
+      "total_chars": 982826
+    },
+    "later_local_materialization": {
+      "concatenated_per_row_sha256_hex": "d49717ca76e73c570e18d0229c735e7049d636b7d5fdf3cc371e4877351cf368",
+      "file_sha256": "1bf8cac8f1fae950201eb4161eb76a75bc5f7b4b9665c1a9b16e17aee3d37334",
+      "first_id": "wikitext-0000",
+      "last_id": "wikitext-0999",
+      "local_manifest_sha256": "a3aac6dd98f456bb2a95843f10ca71241d8f40e794bf1f1c83c71bcafd7c06ed",
+      "n_prompts": 1000,
+      "newline_joined_per_row_sha256_hex": "993212d9409cddaf3820330095b656b50231cb15578007ec2ea97229ca9792ad",
+      "row_hash_validation": "all_local_rows_match_embedded_sha256_utf8_text",
+      "total_chars": 982826
+    },
+    "reconciliation": {
+      "aggregate_row_hash_chain_matches": true,
+      "exact_remote_jsonl_byte_identity_verified": false,
+      "original_remote_jsonl_available": false,
+      "row_by_row_remote_comparison_performed": false,
+      "status": "later_local_materialization_matches_remote_aggregate_manifest",
+      "summary_fields_match": [
+        "n_prompts",
+        "total_chars",
+        "first_id",
+        "last_id"
+      ]
+    },
+    "selection_rule_reported": "first 1000 rows with at least 600 characters",
+    "split": "train"
+  },
+  "schema_version": 1,
+  "software": {
+    "anthropic_jacobian_lens_commit": "581d398613e5602a5af361e1c34d3a92ea82ba8e",
+    "fit_runtime": {
+      "python": "3.10.12",
+      "torch": "2.1.0+cu118",
+      "transformers": "4.44.2"
+    }
+  },
+  "source_checkpoint": {
+    "format": "pytorch",
+    "sha256": "f36a99447623e0d777c70951a9148a7a52e42e0df82942e22ce6326f63d8d664"
+  }
+}

requirements.txt

@@ -0,0 +1,2 @@
+safetensors==0.8.0
+torch==2.13.0

scripts/convert_checkpoint.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""Convert the frozen VibeThinker J Lens checkpoint to Safetensors.
+
+The input path is intentionally required at runtime and is never copied into
+the safetensors header or any generated public metadata. The conversion is
+lossless: every FP16 bit pattern is compared after a safetensors round trip.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import torch
+from safetensors import safe_open
+
+SOURCE_SHA256 = "f36a99447623e0d777c70951a9148a7a52e42e0df82942e22ce6326f63d8d664"
+MODEL_ID = "WeiboAI/VibeThinker-3B"
+MODEL_REVISION = "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c"
+SOURCE_LAYERS = tuple(range(0, 36, 2))
+TARGET_LAYER = 35
+D_MODEL = 2048
+N_PROMPTS = 1000
+EXPECTED_TOP_LEVEL_KEYS = {"J", "n_prompts", "source_layers", "d_model"}
+FORBIDDEN_PUBLIC_FRAGMENTS = (
+    os.sep.join(("", "Users", "")),
+    os.sep.join(("", "Volumes", "")),
+    os.sep.join(("", "workspace")),
+)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def tensor_storage_bytes(tensor: torch.Tensor) -> bytes:
+    """Return C-contiguous little-endian bytes, including FP16 bit patterns."""
+
+    array = tensor.detach().cpu().contiguous().view(torch.int16).numpy()
+    return array.astype("<i2", copy=False).tobytes(order="C")
+
+
+def tensor_sha256(tensor: torch.Tensor) -> str:
+    return hashlib.sha256(tensor_storage_bytes(tensor)).hexdigest()
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.write_text(
+        json.dumps(value, indent=2, sort_keys=True, ensure_ascii=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def validate_source(checkpoint: Any) -> dict[int, torch.Tensor]:
+    require(isinstance(checkpoint, Mapping), "checkpoint must be a mapping")
+    require(
+        set(checkpoint) == EXPECTED_TOP_LEVEL_KEYS,
+        f"unexpected checkpoint keys: {sorted(checkpoint)}",
+    )
+    require(checkpoint["n_prompts"] == N_PROMPTS, "unexpected n_prompts")
+    require(checkpoint["d_model"] == D_MODEL, "unexpected d_model")
+    require(
+        tuple(checkpoint["source_layers"]) == SOURCE_LAYERS,
+        "unexpected source_layers",
+    )
+
+    matrices = checkpoint["J"]
+    require(isinstance(matrices, Mapping), "J must be a layer-to-tensor mapping")
+    require(set(matrices) == set(SOURCE_LAYERS), "unexpected J layer keys")
+
+    validated: dict[int, torch.Tensor] = {}
+    for layer in SOURCE_LAYERS:
+        tensor = matrices[layer]
+        require(isinstance(tensor, torch.Tensor), f"J[{layer}] is not a tensor")
+        require(tensor.device.type == "cpu", f"J[{layer}] is not on CPU")
+        require(tensor.dtype == torch.float16, f"J[{layer}] is not FP16")
+        require(tuple(tensor.shape) == (D_MODEL, D_MODEL), f"J[{layer}] shape mismatch")
+        require(tensor.is_contiguous(), f"J[{layer}] is not contiguous")
+        require(bool(torch.isfinite(tensor).all()), f"J[{layer}] contains non-finite values")
+        validated[layer] = tensor
+    return validated
+
+
+def public_header() -> dict[str, str]:
+    return {
+        "artifact_kind": "jacobian_lens",
+        "d_model": str(D_MODEL),
+        "format": "pt",
+        "model_id": MODEL_ID,
+        "model_revision": MODEL_REVISION,
+        "n_prompts": str(N_PROMPTS),
+        "schema_version": "1",
+        "source_checkpoint_sha256": SOURCE_SHA256,
+        "source_layers": json.dumps(SOURCE_LAYERS, separators=(",", ":")),
+        "target_layer": str(TARGET_LAYER),
+        "tensor_dtype": "float16",
+        "tensor_key_pattern": "J.{source_layer}",
+    }
+
+
+def assert_public_header(metadata: Mapping[str, str]) -> None:
+    encoded = json.dumps(dict(metadata), sort_keys=True)
+    for fragment in FORBIDDEN_PUBLIC_FRAGMENTS:
+        require(fragment not in encoded, f"private fragment found in safetensors header: {fragment}")
+
+
+def save_deterministic_safetensors(
+    tensors: Mapping[str, torch.Tensor],
+    path: Path,
+    metadata: Mapping[str, str],
+) -> None:
+    """Write the documented safetensors format with canonical key ordering.
+
+    The upstream writer preserves tensor data exactly, but its Rust metadata
+    map can serialize keys in a process-random order. Canonical JSON ordering
+    makes the complete artifact reproducible byte for byte across runs.
+    """
+
+    offset = 0
+    header: dict[str, Any] = {
+        "__metadata__": {key: metadata[key] for key in sorted(metadata)}
+    }
+    for key in sorted(tensors):
+        tensor = tensors[key]
+        require(tensor.dtype == torch.float16, f"{key} is not FP16")
+        nbytes = tensor.numel() * tensor.element_size()
+        header[key] = {
+            "dtype": "F16",
+            "shape": list(tensor.shape),
+            "data_offsets": [offset, offset + nbytes],
+        }
+        offset += nbytes
+
+    encoded_header = json.dumps(
+        header,
+        ensure_ascii=False,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    padding = (-len(encoded_header)) % 8
+    encoded_header += b" " * padding
+
+    with path.open("wb") as handle:
+        handle.write(len(encoded_header).to_bytes(8, byteorder="little", signed=False))
+        handle.write(encoded_header)
+        for key in sorted(tensors):
+            handle.write(tensor_storage_bytes(tensors[key]))
+
+
+def convert(source: Path, output_dir: Path, overwrite: bool) -> dict[str, Any]:
+    source_digest = sha256_file(source)
+    require(source_digest == SOURCE_SHA256, "source checkpoint SHA-256 mismatch")
+
+    checkpoint = torch.load(source, map_location="cpu", weights_only=True)
+    matrices = validate_source(checkpoint)
+    tensors = {f"J.{layer}": matrices[layer] for layer in SOURCE_LAYERS}
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_path = output_dir / "model.safetensors"
+    if output_path.exists() and not overwrite:
+        raise FileExistsError(f"refusing to overwrite {output_path.name}; pass --overwrite")
+
+    metadata = public_header()
+    assert_public_header(metadata)
+    temporary_path = output_dir / ".model.safetensors.tmp"
+    save_deterministic_safetensors(tensors, temporary_path, metadata)
+    os.replace(temporary_path, output_path)
+
+    manifest_tensors: dict[str, Any] = {}
+    exact_matches = 0
+    with safe_open(output_path, framework="pt", device="cpu") as artifact:
+        stored_metadata = artifact.metadata() or {}
+        require(stored_metadata == metadata, "safetensors metadata changed during serialization")
+        assert_public_header(stored_metadata)
+        require(set(artifact.keys()) == set(tensors), "safetensors key set mismatch")
+
+        for layer in SOURCE_LAYERS:
+            key = f"J.{layer}"
+            source_tensor = matrices[layer]
+            output_tensor = artifact.get_tensor(key)
+            require(output_tensor.dtype == source_tensor.dtype, f"{key} dtype mismatch")
+            require(tuple(output_tensor.shape) == tuple(source_tensor.shape), f"{key} shape mismatch")
+            require(output_tensor.is_contiguous(), f"{key} is not contiguous")
+            require(torch.equal(output_tensor, source_tensor), f"{key} value mismatch")
+            require(
+                torch.equal(output_tensor.view(torch.int16), source_tensor.view(torch.int16)),
+                f"{key} FP16 bit-pattern mismatch",
+            )
+            source_tensor_digest = tensor_sha256(source_tensor)
+            output_tensor_digest = tensor_sha256(output_tensor)
+            require(source_tensor_digest == output_tensor_digest, f"{key} byte hash mismatch")
+            exact_matches += 1
+            manifest_tensors[key] = {
+                "dtype": "float16",
+                "nbytes": source_tensor.numel() * source_tensor.element_size(),
+                "numel": source_tensor.numel(),
+                "sha256_c_contiguous_little_endian_bytes": source_tensor_digest,
+                "shape": list(source_tensor.shape),
+                "source_layer": layer,
+            }
+
+    output_digest = sha256_file(output_path)
+    output_size = output_path.stat().st_size
+    tensor_manifest = {
+        "artifact": "model.safetensors",
+        "artifact_sha256": output_digest,
+        "artifact_size_bytes": output_size,
+        "schema_version": 1,
+        "tensor_count": len(manifest_tensors),
+        "tensor_storage_bytes": sum(item["nbytes"] for item in manifest_tensors.values()),
+        "tensors": manifest_tensors,
+    }
+    validation = {
+        "artifact": "model.safetensors",
+        "artifact_sha256": output_digest,
+        "artifact_size_bytes": output_size,
+        "checks": {
+            "all_source_tensors_contiguous": True,
+            "all_source_tensors_finite": True,
+            "all_source_tensors_fp16": True,
+            "all_source_tensors_shape_2048x2048": True,
+            "roundtrip_all_tensor_byte_hashes_equal": True,
+            "roundtrip_all_tensor_dtypes_equal": True,
+            "roundtrip_all_tensor_shapes_equal": True,
+            "roundtrip_all_tensor_values_equal": True,
+            "roundtrip_all_tensor_bit_patterns_equal": True,
+            "roundtrip_key_set_exact": True,
+            "safetensors_header_public_safe": True,
+            "safetensors_header_roundtrip_exact": True,
+            "source_checkpoint_sha256_exact": True,
+            "source_metadata_exact": True,
+            "source_top_level_key_set_exact": True,
+        },
+        "exact_tensor_matches": exact_matches,
+        "expected_tensor_matches": len(SOURCE_LAYERS),
+        "ok": exact_matches == len(SOURCE_LAYERS),
+        "schema_version": 1,
+        "source_checkpoint_sha256": source_digest,
+        "tensor_values_changed": 0,
+    }
+    write_json(output_dir / "tensor_manifest.json", tensor_manifest)
+    write_json(output_dir / "validation.json", validation)
+    (output_dir / "SHA256SUMS").write_text(
+        f"{output_digest}  model.safetensors\n",
+        encoding="ascii",
+    )
+    return validation
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", required=True, type=Path, help="Private source .pt checkpoint")
+    parser.add_argument("--output-dir", required=True, type=Path, help="Public artifact directory")
+    parser.add_argument("--overwrite", action="store_true")
+    args = parser.parse_args()
+
+    result = convert(args.source, args.output_dir, args.overwrite)
+    print(json.dumps(result, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_evaluation_checkpoint.py

@@ -0,0 +1,439 @@
+#!/usr/bin/env python3
+"""Convert the frozen FP32 evaluation lens to deterministic Safetensors."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+import safetensors
+import torch
+from safetensors import safe_open
+
+SOURCE_SHA256 = "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9"
+SOURCE_PROVENANCE_SHA256 = (
+    "b6e5764fa1580a142403a425ecd03cafe55d4cc36ca1e6b90da7fc19a35aad36"
+)
+SOURCE_VALIDATION_SHA256 = (
+    "4aea71008a10ef2d043129f7767e5d387372fe1fd5022550b59017a44e0b965d"
+)
+SOURCE_MATRIX_STATS_SHA256 = (
+    "a21fe7c1f661fa9b5455d89c0a415beae794012eab38f782b667b27fac942401"
+)
+SOURCE_FIT_CHECKPOINT_SHA256 = (
+    "a1236cfe5d04601575b3de150ffe50e3a67e755ede1197ecf74c205a31bdc258"
+)
+SOURCE_EXPORT_SCRIPT_SHA256 = (
+    "d1d9e0b7afd1d69771907a839f62b30936995fdd63b17ea2ac80f724b3cdce17"
+)
+FP16_ARTIFACT_SHA256 = (
+    "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c"
+)
+MODEL_ID = "WeiboAI/VibeThinker-3B"
+MODEL_REVISION = "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c"
+SOURCE_LAYERS = tuple(range(0, 36, 2))
+TARGET_LAYER = 35
+D_MODEL = 2048
+N_PROMPTS = 1000
+EXPECTED_TOP_LEVEL_KEYS = {"J", "n_prompts", "source_layers", "d_model"}
+FORBIDDEN_PUBLIC_FRAGMENTS = (
+    os.sep.join(("", "Users", "")),
+    os.sep.join(("", "Volumes", "")),
+    os.sep.join(("", "workspace")),
+)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def tensor_storage_bytes(tensor: torch.Tensor) -> bytes:
+    """Return C-contiguous little-endian FP32 bytes without value conversion."""
+
+    array = tensor.detach().cpu().contiguous().view(torch.int32).numpy()
+    return array.astype("<i4", copy=False).tobytes(order="C")
+
+
+def tensor_sha256(tensor: torch.Tensor) -> str:
+    return hashlib.sha256(tensor_storage_bytes(tensor)).hexdigest()
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.write_text(
+        json.dumps(value, indent=2, sort_keys=True, ensure_ascii=True) + "\n",
+        encoding="utf-8",
+    )
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def validate_source(checkpoint: Any) -> dict[int, torch.Tensor]:
+    require(isinstance(checkpoint, Mapping), "checkpoint must be a mapping")
+    require(
+        set(checkpoint) == EXPECTED_TOP_LEVEL_KEYS,
+        f"unexpected checkpoint keys: {sorted(checkpoint)}",
+    )
+    require(checkpoint["n_prompts"] == N_PROMPTS, "unexpected n_prompts")
+    require(checkpoint["d_model"] == D_MODEL, "unexpected d_model")
+    require(
+        tuple(checkpoint["source_layers"]) == SOURCE_LAYERS,
+        "unexpected source_layers",
+    )
+    matrices = checkpoint["J"]
+    require(isinstance(matrices, Mapping), "J must be a layer-to-tensor mapping")
+    require(set(matrices) == set(SOURCE_LAYERS), "unexpected J layer keys")
+
+    validated: dict[int, torch.Tensor] = {}
+    for layer in SOURCE_LAYERS:
+        tensor = matrices[layer]
+        require(isinstance(tensor, torch.Tensor), f"J[{layer}] is not a tensor")
+        require(tensor.device.type == "cpu", f"J[{layer}] is not on CPU")
+        require(tensor.dtype == torch.float32, f"J[{layer}] is not FP32")
+        require(
+            tuple(tensor.shape) == (D_MODEL, D_MODEL),
+            f"J[{layer}] shape mismatch",
+        )
+        require(tensor.is_contiguous(), f"J[{layer}] is not contiguous")
+        require(
+            bool(torch.isfinite(tensor).all()),
+            f"J[{layer}] contains non-finite values",
+        )
+        validated[layer] = tensor
+    return validated
+
+
+def public_header() -> dict[str, str]:
+    return {
+        "artifact_kind": "jacobian_lens_evaluation_fp32",
+        "d_model": str(D_MODEL),
+        "format": "pt",
+        "model_id": MODEL_ID,
+        "model_revision": MODEL_REVISION,
+        "n_prompts": str(N_PROMPTS),
+        "schema_version": "1",
+        "source_fit_checkpoint_sha256": SOURCE_FIT_CHECKPOINT_SHA256,
+        "source_fp32_checkpoint_sha256": SOURCE_SHA256,
+        "source_layers": json.dumps(SOURCE_LAYERS, separators=(",", ":")),
+        "target_layer": str(TARGET_LAYER),
+        "tensor_dtype": "float32",
+        "tensor_key_pattern": "J.{source_layer}",
+    }
+
+
+def assert_public_header(metadata: Mapping[str, str]) -> None:
+    encoded = json.dumps(dict(metadata), sort_keys=True)
+    for fragment in FORBIDDEN_PUBLIC_FRAGMENTS:
+        require(
+            fragment not in encoded,
+            f"private fragment found in Safetensors header: {fragment}",
+        )
+
+
+def save_deterministic_safetensors(
+    tensors: Mapping[str, torch.Tensor],
+    path: Path,
+    metadata: Mapping[str, str],
+) -> None:
+    offset = 0
+    header: dict[str, Any] = {
+        "__metadata__": {key: metadata[key] for key in sorted(metadata)}
+    }
+    for key in sorted(tensors):
+        tensor = tensors[key]
+        require(tensor.dtype == torch.float32, f"{key} is not FP32")
+        nbytes = tensor.numel() * tensor.element_size()
+        header[key] = {
+            "dtype": "F32",
+            "shape": list(tensor.shape),
+            "data_offsets": [offset, offset + nbytes],
+        }
+        offset += nbytes
+
+    encoded_header = json.dumps(
+        header,
+        ensure_ascii=False,
+        separators=(",", ":"),
+    ).encode("utf-8")
+    encoded_header += b" " * ((-len(encoded_header)) % 8)
+    with path.open("wb") as handle:
+        handle.write(len(encoded_header).to_bytes(8, "little", signed=False))
+        handle.write(encoded_header)
+        for key in sorted(tensors):
+            handle.write(tensor_storage_bytes(tensors[key]))
+
+
+def compare_fp16(
+    matrices: Mapping[int, torch.Tensor],
+    fp16_path: Path,
+) -> dict[str, Any]:
+    require(
+        sha256_file(fp16_path) == FP16_ARTIFACT_SHA256,
+        "FP16 companion artifact SHA-256 mismatch",
+    )
+    per_layer: dict[str, Any] = {}
+    error_squared = 0.0
+    reference_squared = 0.0
+    with safe_open(fp16_path, framework="pt", device="cpu") as fp16_artifact:
+        require(
+            set(fp16_artifact.keys()) == {f"J.{layer}" for layer in SOURCE_LAYERS},
+            "FP16 companion key set mismatch",
+        )
+        for layer in SOURCE_LAYERS:
+            fp32 = matrices[layer]
+            stored_fp16 = fp16_artifact.get_tensor(f"J.{layer}")
+            cast_fp16 = fp32.to(torch.float16)
+            require(
+                torch.equal(cast_fp16.view(torch.int16), stored_fp16.view(torch.int16)),
+                f"FP32-to-FP16 cast differs at J.{layer}",
+            )
+            error = cast_fp16.float() - fp32
+            error_norm = float(torch.linalg.vector_norm(error))
+            reference_norm = float(torch.linalg.vector_norm(fp32))
+            layer_error_squared = error_norm**2
+            layer_reference_squared = reference_norm**2
+            error_squared += layer_error_squared
+            reference_squared += layer_reference_squared
+            per_layer[str(layer)] = {
+                "cast_matches_model_safetensors_exactly": True,
+                "max_absolute_error": float(error.abs().max().item()),
+                "relative_frobenius_error": error_norm / reference_norm,
+            }
+    return {
+        "schema_version": 1,
+        "artifact_kind": "fp32_to_fp16_lens_compatibility",
+        "fp32_source_checkpoint_sha256": SOURCE_SHA256,
+        "fp16_artifact": "model.safetensors",
+        "fp16_artifact_sha256": FP16_ARTIFACT_SHA256,
+        "conversion": "IEEE_FP32_to_FP16_round_to_nearest_even",
+        "all_layer_casts_match_exactly": True,
+        "relative_frobenius_error": (error_squared / reference_squared) ** 0.5,
+        "max_absolute_error": max(
+            record["max_absolute_error"] for record in per_layer.values()
+        ),
+        "per_layer": per_layer,
+    }
+
+
+def convert(source: Path, output_dir: Path, overwrite: bool) -> dict[str, Any]:
+    source_digest = sha256_file(source)
+    require(source_digest == SOURCE_SHA256, "source checkpoint SHA-256 mismatch")
+    checkpoint = torch.load(source, map_location="cpu", weights_only=True)
+    matrices = validate_source(checkpoint)
+    tensors = {f"J.{layer}": matrices[layer] for layer in SOURCE_LAYERS}
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    output_path = output_dir / "evaluation.safetensors"
+    if output_path.exists() and not overwrite:
+        raise FileExistsError(
+            f"refusing to overwrite {output_path.name}; pass --overwrite"
+        )
+    metadata = public_header()
+    assert_public_header(metadata)
+    temporary_path = output_dir / ".evaluation.safetensors.tmp"
+    save_deterministic_safetensors(tensors, temporary_path, metadata)
+    os.replace(temporary_path, output_path)
+
+    manifest_tensors: dict[str, Any] = {}
+    exact_matches = 0
+    with safe_open(output_path, framework="pt", device="cpu") as artifact:
+        stored_metadata = artifact.metadata() or {}
+        require(stored_metadata == metadata, "Safetensors metadata changed")
+        assert_public_header(stored_metadata)
+        require(set(artifact.keys()) == set(tensors), "Safetensors key set mismatch")
+        for layer in SOURCE_LAYERS:
+            key = f"J.{layer}"
+            source_tensor = matrices[layer]
+            output_tensor = artifact.get_tensor(key)
+            require(output_tensor.dtype == torch.float32, f"{key} dtype mismatch")
+            require(
+                tuple(output_tensor.shape) == (D_MODEL, D_MODEL),
+                f"{key} shape mismatch",
+            )
+            require(output_tensor.is_contiguous(), f"{key} is not contiguous")
+            require(torch.equal(output_tensor, source_tensor), f"{key} value mismatch")
+            require(
+                torch.equal(
+                    output_tensor.view(torch.int32),
+                    source_tensor.view(torch.int32),
+                ),
+                f"{key} FP32 bit-pattern mismatch",
+            )
+            source_tensor_digest = tensor_sha256(source_tensor)
+            require(
+                tensor_sha256(output_tensor) == source_tensor_digest,
+                f"{key} raw byte hash mismatch",
+            )
+            exact_matches += 1
+            manifest_tensors[key] = {
+                "dtype": "float32",
+                "nbytes": source_tensor.numel() * source_tensor.element_size(),
+                "numel": source_tensor.numel(),
+                "sha256_c_contiguous_little_endian_bytes": source_tensor_digest,
+                "shape": list(source_tensor.shape),
+                "source_layer": layer,
+            }
+
+    output_digest = sha256_file(output_path)
+    output_size = output_path.stat().st_size
+    manifest = {
+        "schema_version": 1,
+        "artifact": "evaluation.safetensors",
+        "artifact_sha256": output_digest,
+        "artifact_size_bytes": output_size,
+        "source_checkpoint_sha256": source_digest,
+        "tensor_count": len(manifest_tensors),
+        "tensor_storage_bytes": sum(
+            record["nbytes"] for record in manifest_tensors.values()
+        ),
+        "tensors": manifest_tensors,
+    }
+    compatibility = compare_fp16(matrices, output_dir / "model.safetensors")
+    compatibility["fp32_artifact"] = "evaluation.safetensors"
+    compatibility["fp32_artifact_sha256"] = output_digest
+    validation = {
+        "schema_version": 1,
+        "artifact": "evaluation.safetensors",
+        "artifact_sha256": output_digest,
+        "artifact_size_bytes": output_size,
+        "source_checkpoint_sha256": source_digest,
+        "exact_tensor_matches": exact_matches,
+        "expected_tensor_matches": len(SOURCE_LAYERS),
+        "tensor_values_changed": 0,
+        "checks": {
+            "all_source_tensors_contiguous": True,
+            "all_source_tensors_finite": True,
+            "all_source_tensors_fp32": True,
+            "all_source_tensors_shape_2048x2048": True,
+            "fp16_cast_matches_companion_artifact": True,
+            "roundtrip_all_tensor_byte_hashes_equal": True,
+            "roundtrip_all_tensor_dtypes_equal": True,
+            "roundtrip_all_tensor_shapes_equal": True,
+            "roundtrip_all_tensor_values_equal": True,
+            "roundtrip_all_tensor_bit_patterns_equal": True,
+            "roundtrip_key_set_exact": True,
+            "safetensors_header_public_safe": True,
+            "safetensors_header_roundtrip_exact": True,
+            "source_checkpoint_sha256_exact": True,
+            "source_metadata_exact": True,
+            "source_top_level_key_set_exact": True,
+        },
+        "ok": exact_matches == len(SOURCE_LAYERS),
+    }
+    provenance = {
+        "schema_version": 1,
+        "artifact_kind": "jacobian_lens_evaluation_fp32_provenance",
+        "artifact": {
+            "filename": "evaluation.safetensors",
+            "format": "safetensors",
+            "sha256": output_digest,
+            "size_bytes": output_size,
+            "tensor_conversion": "lossless_fp32_reserialization",
+        },
+        "source_checkpoint": {
+            "format": "pytorch",
+            "sha256": source_digest,
+        },
+        "derivation": {
+            "formula": "jacobian_sum[layer] / n_done",
+            "n_done": N_PROMPTS,
+            "source_fit_checkpoint_sha256": SOURCE_FIT_CHECKPOINT_SHA256,
+            "source_export_script_sha256": SOURCE_EXPORT_SCRIPT_SHA256,
+            "source_matrix_stats_sha256": SOURCE_MATRIX_STATS_SHA256,
+            "source_provenance_sha256": SOURCE_PROVENANCE_SHA256,
+            "source_validation_sha256": SOURCE_VALIDATION_SHA256,
+        },
+        "model": {
+            "architecture": "Qwen2ForCausalLM",
+            "d_model": D_MODEL,
+            "id": MODEL_ID,
+            "n_layers": 36,
+            "revision": MODEL_REVISION,
+            "revision_binding": "inferred_hub_head_unchanged_since_before_fit",
+            "revision_last_modified": "2026-06-30T11:35:41+00:00",
+            "tied_embeddings": True,
+        },
+        "lens": {
+            "d_model": D_MODEL,
+            "dtype": "float32",
+            "hook_convention": "post_transformer_block_output_residual",
+            "n_prompts": N_PROMPTS,
+            "source_layers": list(SOURCE_LAYERS),
+            "target_layer": TARGET_LAYER,
+            "estimator": {
+                "dim_batch": 8,
+                "exclude_final_position": True,
+                "fit_dtype": "bfloat16",
+                "max_seq_len": 128,
+                "name": "causal_all_current_and_future_targets_mean_jacobian",
+                "prompt_aggregation": "equal_weight_mean_over_prompts",
+                "skip_first": 16,
+                "source_position_aggregation": "mean_over_valid_source_positions",
+                "target_position_aggregation": (
+                    "sum_over_valid_targets_at_or_after_source"
+                ),
+            },
+        },
+        "compatibility": {
+            "file": "evaluation_compatibility.json",
+            "fp16_artifact": "model.safetensors",
+            "fp16_artifact_sha256": FP16_ARTIFACT_SHA256,
+            "all_layer_casts_match_exactly": True,
+        },
+        "software": {
+            "conversion_runtime": {
+                "python_implementation": "CPython",
+                "safetensors": safetensors.__version__,
+                "torch": torch.__version__,
+            },
+            "anthropic_jacobian_lens_commit": (
+                "581d398613e5602a5af361e1c34d3a92ea82ba8e"
+            ),
+        },
+        "limitations": [
+            "The original fit did not store the resolved Hugging Face commit; the revision binding was reconstructed from the Hub head and its last-modified timestamp.",
+            "The recorded evaluation validates token readout and does not establish causal steering or a global workspace.",
+        ],
+    }
+
+    write_json(output_dir / "evaluation_tensor_manifest.json", manifest)
+    write_json(output_dir / "evaluation_compatibility.json", compatibility)
+    write_json(output_dir / "evaluation_validation.json", validation)
+    write_json(output_dir / "evaluation_provenance.json", provenance)
+    return {
+        "artifact": output_path.name,
+        "artifact_sha256": output_digest,
+        "artifact_size_bytes": output_size,
+        "exact_tensor_matches": exact_matches,
+        "fp16_cast_matches": compatibility["all_layer_casts_match_exactly"],
+        "source_checkpoint_sha256": source_digest,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source", required=True, type=Path)
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path(__file__).resolve().parents[1],
+    )
+    parser.add_argument("--overwrite", action="store_true")
+    args = parser.parse_args()
+    result = convert(args.source, args.output_dir.resolve(), args.overwrite)
+    print(json.dumps(result, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_artifact.py

@@ -0,0 +1,1395 @@
+#!/usr/bin/env python3
+"""Validate the public model-release candidate without the private source file."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import re
+import subprocess
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+import torch
+from safetensors import safe_open
+
+MODEL_ID = "WeiboAI/VibeThinker-3B"
+MODEL_REVISION = "77bd2cced09193c8b9a59a32bd8577bbd1f3e01c"
+SOURCE_CHECKPOINT_SHA256 = (
+    "f36a99447623e0d777c70951a9148a7a52e42e0df82942e22ce6326f63d8d664"
+)
+ARTIFACT_SHA256 = "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c"
+ARTIFACT_SIZE_BYTES = 150_996_824
+EVALUATION_LENS_SHA256 = (
+    "8f752032a26a5196c1cb447ef63f01e8a29820ff0c57178dd80c6e26d32b12a9"
+)
+EVALUATION_ARTIFACT_SHA256 = (
+    "0cc184eb65d273ac8bfee5450a141c8cdf8dd6ec8caa68d7d47260ef621777d1"
+)
+EVALUATION_ARTIFACT_SIZE_BYTES = 301_991_904
+EVALUATION_FILE_SHA256 = (
+    "073f2886e370acec7dd1564f2d7e834b4253493e84b026ec0cc017a6069a5f78"
+)
+SOURCE_LAYERS = tuple(range(0, 36, 2))
+SELECTED_BAND = (24, 26, 28, 30, 32, 34)
+D_MODEL = 2048
+TENSOR_NBYTES = D_MODEL * D_MODEL * 2
+TENSOR_STORAGE_BYTES = len(SOURCE_LAYERS) * TENSOR_NBYTES
+EVALUATION_TENSOR_NBYTES = D_MODEL * D_MODEL * 4
+EVALUATION_TENSOR_STORAGE_BYTES = len(SOURCE_LAYERS) * EVALUATION_TENSOR_NBYTES
+EXPECTED_KEYS = {f"J.{layer}" for layer in SOURCE_LAYERS}
+EXPECTED_TENSOR_RECORD_KEYS = {
+    "dtype",
+    "nbytes",
+    "numel",
+    "sha256_c_contiguous_little_endian_bytes",
+    "shape",
+    "source_layer",
+}
+EXPECTED_METADATA = {
+    "artifact_kind": "jacobian_lens",
+    "d_model": str(D_MODEL),
+    "format": "pt",
+    "model_id": MODEL_ID,
+    "model_revision": MODEL_REVISION,
+    "n_prompts": "1000",
+    "schema_version": "1",
+    "source_checkpoint_sha256": SOURCE_CHECKPOINT_SHA256,
+    "source_layers": "[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34]",
+    "target_layer": "35",
+    "tensor_dtype": "float16",
+    "tensor_key_pattern": "J.{source_layer}",
+}
+EXPECTED_EVALUATION_METADATA = {
+    "artifact_kind": "jacobian_lens_evaluation_fp32",
+    "d_model": str(D_MODEL),
+    "format": "pt",
+    "model_id": MODEL_ID,
+    "model_revision": MODEL_REVISION,
+    "n_prompts": "1000",
+    "schema_version": "1",
+    "source_fit_checkpoint_sha256": (
+        "a1236cfe5d04601575b3de150ffe50e3a67e755ede1197ecf74c205a31bdc258"
+    ),
+    "source_fp32_checkpoint_sha256": EVALUATION_LENS_SHA256,
+    "source_layers": "[0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34]",
+    "target_layer": "35",
+    "tensor_dtype": "float32",
+    "tensor_key_pattern": "J.{source_layer}",
+}
+EXPECTED_CARD_FRONT_MATTER = """license: other
+license_name: qwen-research-license
+license_link: https://huggingface.co/JacobMolBio/vibethinker-3b-jlens-model/blob/main/LICENSES/QWEN-RESEARCH.txt
+tags:
+- vibethinker-3b
+- jacobian-lens
+- mechanistic-interpretability
+- interpretability
+- qwen2
+- safetensors"""
+EXPECTED_RELEASE_FILES = {
+    ".gitattributes",
+    ".gitignore",
+    "assets/jlens-model-banner.png",
+    "assets/two-lens-files.png",
+    "assets/two-lens-files.svg",
+    "LICENSES/APACHE-2.0.txt",
+    "LICENSES/QWEN-RESEARCH.txt",
+    "LICENSES/VIBETHINKER-LICENSE-NOTE.txt",
+    "NOTICE",
+    "README.md",
+    "SHA256SUMS",
+    "THIRD_PARTY_NOTICES.md",
+    "evaluation.json",
+    "evaluation.safetensors",
+    "evaluation_compatibility.json",
+    "evaluation_provenance.json",
+    "evaluation_tensor_manifest.json",
+    "evaluation_validation.json",
+    "lens_config.json",
+    "model.safetensors",
+    "provenance.json",
+    "requirements.txt",
+    "scripts/convert_checkpoint.py",
+    "scripts/convert_evaluation_checkpoint.py",
+    "scripts/validate_artifact.py",
+    "tensor_manifest.json",
+    "validation.json",
+}
+PINNED_PUBLIC_FILE_SHA256 = {
+    ".gitattributes": "cd0273298656ca90cb8d08fd25b7601483f7e13417e3115ab809856c42e794f7",
+    ".gitignore": "4c7486a4b7c5ad04e0e62225b9a55c9ae00b039168d34614d402ac1f73acc459",
+    "assets/jlens-model-banner.png": "f27c4abb0c84481c2b0e67ed0c390716905bd1fe6fbcb09f2a65bbe15ecdc935",
+    "LICENSES/APACHE-2.0.txt": "ec01a6d25ea6a6b50430eda7af9e23e1c510048502d0a3adb5b54559e687d4fa",
+    "LICENSES/QWEN-RESEARCH.txt": "ef52482bb785733093dc9a2e8edd8e764c77d12d8e9d8f10a80c9b547d32d0f9",
+    "LICENSES/VIBETHINKER-LICENSE-NOTE.txt": "a74ea19436fbab1210ff16aa9037337d95ca9f93675406da4383bd8de4f4d25b",
+    "NOTICE": "35d9d57e97593a99aff4434875b43943d7627258495466bd5f8f81cdd8d40289",
+    "THIRD_PARTY_NOTICES.md": "d68e3b08646b56bf8d8c80d1d1acd98edfb40e72cb287762a3150d9b9d75a18f",
+}
+PUBLICATION_ROWS = {
+    "CODE_REPOSITORY_URL": "Source code and Pages source",
+    "TRACE_REPOSITORY_URL": "Captured trace dataset",
+    "PUBLIC_SITE_URL": "Static Pages site",
+    "MODEL_REPOSITORY_ID": "Hugging Face model repository ID",
+}
+PUBLICATION_PLACEHOLDERS = {key: "{{" + key + "}}" for key in PUBLICATION_ROWS}
+CODE_REPOSITORY_NAME = "vibethinker-3b-jlens"
+TRACE_REPOSITORY_NAME = "vibethinker-3b-jlens-traces"
+MODEL_REPOSITORY_NAME = "vibethinker-3b-jlens-model"
+REPOSITORY_COMPONENT = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.-]*")
+SHA256_PATTERN = re.compile(r"[0-9a-f]{64}")
+PUBLICATION_SENTINELS = {
+    "",
+    "example",
+    "local",
+    "none",
+    "null",
+    "org",
+    "organization",
+    "placeholder",
+    "repo",
+    "repository",
+    "tbd",
+    "todo",
+    "user",
+    "username",
+}
+FORBIDDEN_PUBLIC_PATTERNS = {
+    "email address": re.compile(
+        r"\b[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+"
+        + chr(64)
+        + r"[A-Za-z0-9](?:[A-Za-z0-9.-]{0,61}[A-Za-z0-9])?"
+        + r"\.[A-Za-z]{2,}\b"
+    ),
+    "AWS access key": re.compile(r"\b" + "AK" + r"IA[0-9A-Z]{16}\b"),
+    "AWS temporary access key": re.compile(r"\b" + "AS" + r"IA[0-9A-Z]{16}\b"),
+    "GitHub access token": re.compile(r"\b" + "gh" + r"[pousr]_[A-Za-z0-9]{20,}\b"),
+    "GitHub fine-grained token": re.compile(
+        r"\b" + "github" + r"_pat_[A-Za-z0-9_]{20,}\b"
+    ),
+    "GitLab access token": re.compile(r"\b" + "gl" + r"pat-[A-Za-z0-9_-]{20,}\b"),
+    "Hugging Face access token": re.compile(r"\b" + "hf" + r"_[A-Za-z0-9]{20,}\b"),
+    "OpenAI-style access token": re.compile(r"\b" + "sk" + r"-[A-Za-z0-9_-]{20,}\b"),
+    "Google API key": re.compile(r"\b" + "AI" + r"za[0-9A-Za-z_-]{30,}\b"),
+    "Slack access token": re.compile(r"\b" + "xo" + r"[abprs]-[A-Za-z0-9-]{20,}\b"),
+    "private key": re.compile(
+        "-----BEGIN " + r"(?:DSA |EC |OPENSSH |RSA )?PRIVATE KEY-----"
+    ),
+    "bearer credential": re.compile(
+        r"\b" + "Bearer" + r"\s+[A-Za-z0-9._~+/=-]{20,}", re.IGNORECASE
+    ),
+    "local file URI": re.compile(r"\b" + "file:" + r"//", re.IGNORECASE),
+    "macOS user path": re.compile(r"(?<![A-Za-z0-9:])/" + r"Users/[^/\s]+/"),
+    "mounted volume path": re.compile(r"(?<![A-Za-z0-9:])/" + r"Volumes/[^/\s]+/"),
+    "Unix home path": re.compile(r"(?<![A-Za-z0-9:])/" + r"home/[^/\s]+/"),
+    "root home path": re.compile(r"(?<![A-Za-z0-9:])/" + r"root(?:/|\b)"),
+    "temporary path": re.compile(
+        r"(?<![A-Za-z0-9:])/" + r"(?:tmp|private/tmp|var/folders)/"
+    ),
+    "workspace path": re.compile(r"(?<![A-Za-z0-9:])/" + r"workspaces?/[^\s]+"),
+    "mounted data path": re.compile(r"(?<![A-Za-z0-9:])/" + r"mnt/[^\s]+"),
+    "Windows user path": re.compile(r"[A-Za-z]:\\" + r"Users\\[^\\\s]+\\"),
+    "loopback hostname": re.compile(r"\b" + "local" + r"host\b", re.IGNORECASE),
+    "loopback IPv4 address": re.compile(r"\b127(?:\.[0-9]{1,3}){3}\b"),
+    "unspecified IPv4 address": re.compile(r"\b0\.0\.0\.0\b"),
+}
+FORBIDDEN_PUBLIC_LITERALS = {
+    "local account name": "jacob" + "vogan",
+    "local account alias": "jaco" + "vogan",
+    "invented VibeThinker copyright": "Copyright (c) 2025 " + "WeiboAI",
+    "removed VibeThinker license filename": "VIBETHINKER-" + "MIT.txt",
+}
+EXPECTED_EVALUATION_CLAIM_BOUNDARY = (
+    "This reference records the V1 readout results. It excludes causal-assay "
+    "results and does not establish free-generation steering or a global "
+    "workspace."
+)
+EXPECTED_EVALUATION_NOTE = (
+    "The recorded readout metrics bind to evaluation.safetensors, the FP32 "
+    "evaluation lens in this repository. They do not evaluate "
+    "model.safetensors, the FP16 lens used for the captured traces."
+)
+EXPECTED_EVALUATION_TASK = {
+    "aggregate_mean_reciprocal_rank": (
+        "mean_across_eligible_target_terms_of_reciprocal_best_rank"
+    ),
+    "eligible_target": ("at_least_one_candidate_form_tokenizes_to_exactly_one_token"),
+    "final_model": (
+        "rank_target_terms_in_the_model_next_token_logits_at_the_score_position"
+    ),
+    "item": "one_prompt_with_one_or_more_target_terms",
+    "layer_scope_reduction": ("best_target_rank_across_layers_in_the_reported_scope"),
+    "no_eligible_target_item": (
+        "none_of_the_item_target_terms_has_an_eligible_single_token_form"
+    ),
+    "paired_bootstrap_mean_reciprocal_rank": (
+        "within_item_mean_of_reciprocal_best_rank_across_eligible_target_terms"
+    ),
+    "pass_at_k": (
+        "mean_across_items_of_the_fraction_of_item_target_terms_with_best_rank_at_most_k"
+    ),
+    "score_position": {
+        "default": "final_prompt_token",
+        "poetry": "last_newline_token",
+    },
+    "split": {
+        "dev_fraction": 0.3,
+        "method": "sha256_stable_split",
+        "seed": "vibethinker-jlens-v1",
+    },
+    "suites": [
+        "association",
+        "multihop",
+        "multilingual",
+        "order-ops",
+        "poetry",
+        "typo",
+    ],
+    "target_candidate_forms": [
+        "original_lowercase_and_capitalized_forms_with_and_without_leading_space",
+        "order_ops_also_adds_configured_operation_synonyms_and_number_word_digit_forms",
+    ],
+    "target_rank": ("best_one_based_vocabulary_rank_among_eligible_target_token_ids"),
+}
+
+
+def require(condition: bool, message: str) -> None:
+    if not condition:
+        raise ValueError(message)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def tensor_sha256(tensor: torch.Tensor) -> str:
+    contiguous = tensor.detach().cpu().contiguous()
+    if tensor.dtype == torch.float16:
+        array = contiguous.view(torch.int16).numpy()
+        payload = array.astype("<i2", copy=False).tobytes(order="C")
+    elif tensor.dtype == torch.float32:
+        array = contiguous.view(torch.int32).numpy()
+        payload = array.astype("<i4", copy=False).tobytes(order="C")
+    else:
+        raise ValueError(f"unsupported tensor dtype for hashing: {tensor.dtype}")
+    return hashlib.sha256(payload).hexdigest()
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    require(isinstance(value, dict), f"{path.name} must contain a JSON object")
+    return value
+
+
+def normalized_words(value: str) -> str:
+    return " ".join(value.split())
+
+
+def extract_card_front_matter(readme: str) -> str:
+    require(readme.startswith("---\n"), "README model-card front matter is missing")
+    closing = readme.find("\n---\n", 4)
+    require(closing != -1, "README model-card front matter is not closed")
+    return readme[4:closing]
+
+
+def validate_release_file_set(root: Path) -> None:
+    actual_files: set[str] = set()
+    for path in root.rglob("*"):
+        relative = path.relative_to(root)
+        if relative.parts and relative.parts[0] == ".git":
+            continue
+        require(not path.is_symlink(), f"release tree contains a symlink: {relative}")
+        if path.is_file():
+            actual_files.add(relative.as_posix())
+    require(
+        actual_files == EXPECTED_RELEASE_FILES,
+        "release file set mismatch: "
+        f"missing={sorted(EXPECTED_RELEASE_FILES - actual_files)}, "
+        f"extra={sorted(actual_files - EXPECTED_RELEASE_FILES)}",
+    )
+
+
+def validate_pinned_public_files(root: Path) -> None:
+    for relative_path, expected_sha256 in PINNED_PUBLIC_FILE_SHA256.items():
+        require(
+            sha256_file(root / relative_path) == expected_sha256,
+            f"pinned public file hash mismatch: {relative_path}",
+        )
+
+
+def validate_public_text(root: Path) -> None:
+    binary_files = {
+        "assets/jlens-model-banner.png",
+        "assets/two-lens-files.png",
+        "evaluation.safetensors",
+        "model.safetensors",
+    }
+    for relative_path in sorted(EXPECTED_RELEASE_FILES - binary_files):
+        text = (root / relative_path).read_text(encoding="utf-8")
+        for label, pattern in FORBIDDEN_PUBLIC_PATTERNS.items():
+            require(
+                pattern.search(text) is None,
+                f"{relative_path} contains a forbidden {label}",
+            )
+        for label, literal in FORBIDDEN_PUBLIC_LITERALS.items():
+            require(
+                literal not in text,
+                f"{relative_path} contains a forbidden {label}",
+            )
+
+
+def parse_publication_rows(readme: str) -> tuple[dict[str, str], list[str]]:
+    values: dict[str, str] = {}
+    for key, label in PUBLICATION_ROWS.items():
+        pattern = re.compile(
+            rf"^\| {re.escape(label)} \| (?:`([^`\r\n]+)`|\[([^\]\r\n]+)\]\([^\)\r\n]+\)) \|$",
+            re.MULTILINE,
+        )
+        matches = pattern.findall(readme)
+        require(len(matches) == 1, f"README publication row mismatch: {key}")
+        values[key] = matches[0][0] or matches[0][1]
+
+    placeholders_in_readme = set(re.findall(r"\{\{([A-Z0-9_]+)\}\}", readme))
+    unresolved = sorted(
+        key for key, value in values.items() if value == PUBLICATION_PLACEHOLDERS[key]
+    )
+    require(
+        placeholders_in_readme == set(unresolved),
+        "README publication placeholders do not match the publication table",
+    )
+    require(
+        len(unresolved) in {0, len(PUBLICATION_ROWS)},
+        "publication fields must be fully unresolved or fully resolved",
+    )
+    require(
+        f'export JLENS_CODE_REPO_URL="{values["CODE_REPOSITORY_URL"]}"' in readme,
+        "source URL example differs from the publication table",
+    )
+    require(
+        f'export JLENS_MODEL_REPO_ID="{values["MODEL_REPOSITORY_ID"]}"' in readme,
+        "model repository example differs from the publication table",
+    )
+    return values, unresolved
+
+
+def require_public_component(value: str, label: str) -> None:
+    require(value == value.strip(), f"{label} has surrounding whitespace")
+    require(value.casefold() not in PUBLICATION_SENTINELS, f"{label} is a placeholder")
+    require("{{" not in value and "}}" not in value, f"{label} is unresolved")
+    require(
+        not any(character.isspace() for character in value),
+        f"{label} contains whitespace",
+    )
+    require("\\" not in value, f"{label} contains a local path separator")
+
+
+def parse_https_url(value: str, label: str) -> Any:
+    require_public_component(value, label)
+    parsed = urlsplit(value)
+    require(parsed.scheme == "https", f"{label} must use HTTPS")
+    require(parsed.hostname is not None, f"{label} has no hostname")
+    require(
+        parsed.username is None and parsed.password is None,
+        f"{label} contains credentials",
+    )
+    try:
+        port = parsed.port
+    except ValueError as error:
+        raise ValueError(f"{label} has an invalid port") from error
+    require(port is None, f"{label} must not specify a port")
+    require(not parsed.query, f"{label} must not contain a query")
+    require(not parsed.fragment, f"{label} must not contain a fragment")
+    require("%" not in parsed.path, f"{label} must not contain encoded path fragments")
+    require("//" not in parsed.path, f"{label} contains an empty path fragment")
+    require(";" not in parsed.path, f"{label} contains a parameter fragment")
+    return parsed
+
+
+def validate_publication_values(values: dict[str, str]) -> None:
+    code = parse_https_url(values["CODE_REPOSITORY_URL"], "source repository URL")
+    trace = parse_https_url(values["TRACE_REPOSITORY_URL"], "trace repository URL")
+    site = parse_https_url(values["PUBLIC_SITE_URL"], "Pages site URL")
+    model_id = values["MODEL_REPOSITORY_ID"]
+    require_public_component(model_id, "model repository ID")
+
+    code_parts = [part for part in code.path.split("/") if part]
+    require(
+        code.hostname.casefold() == "github.com",
+        "source repository must use github.com",
+    )
+    require(
+        len(code_parts) == 2, "source repository URL must contain namespace/repository"
+    )
+    require(
+        code.path == "/" + "/".join(code_parts),
+        "source repository URL is not canonical",
+    )
+    require(
+        all(REPOSITORY_COMPONENT.fullmatch(part) for part in code_parts),
+        "source repository URL contains an invalid path fragment",
+    )
+    require(
+        code_parts[0].casefold() not in PUBLICATION_SENTINELS,
+        "source namespace is a placeholder",
+    )
+    require(code_parts[1] == CODE_REPOSITORY_NAME, "source repository name mismatch")
+
+    trace_parts = [part for part in trace.path.split("/") if part]
+    require(
+        trace.hostname.casefold() == "huggingface.co",
+        "trace repository must use huggingface.co",
+    )
+    require(
+        len(trace_parts) == 3 and trace_parts[0] == "datasets",
+        "trace repository URL must use /datasets/namespace/repository",
+    )
+    require(
+        trace.path == "/" + "/".join(trace_parts),
+        "trace repository URL is not canonical",
+    )
+    require(
+        all(REPOSITORY_COMPONENT.fullmatch(part) for part in trace_parts[1:]),
+        "trace repository URL contains an invalid path fragment",
+    )
+    require(
+        trace_parts[1].casefold() not in PUBLICATION_SENTINELS,
+        "trace namespace is a placeholder",
+    )
+    require(trace_parts[2] == TRACE_REPOSITORY_NAME, "trace repository name mismatch")
+
+    model_parts = model_id.split("/")
+    require(len(model_parts) == 2, "model repository ID must use namespace/repository")
+    require(
+        all(REPOSITORY_COMPONENT.fullmatch(part) for part in model_parts),
+        "model repository ID contains an invalid fragment",
+    )
+    require(
+        model_parts[0].casefold() not in PUBLICATION_SENTINELS,
+        "model namespace is a placeholder",
+    )
+    require(model_parts[1] == MODEL_REPOSITORY_NAME, "model repository name mismatch")
+    require(
+        model_parts[0].casefold() == trace_parts[1].casefold(),
+        "model and trace repositories must use the same Hugging Face namespace",
+    )
+
+    require(
+        site.hostname.casefold() == f"{code_parts[0].casefold()}.github.io",
+        "Pages hostname must match the source repository namespace",
+    )
+    require(
+        site.path.rstrip("/") == f"/{CODE_REPOSITORY_NAME}",
+        "Pages path must match the source repository name",
+    )
+    require(
+        site.path in {f"/{CODE_REPOSITORY_NAME}", f"/{CODE_REPOSITORY_NAME}/"},
+        "Pages URL is not canonical",
+    )
+
+
+def validate_model_card(readme: str) -> None:
+    require(
+        extract_card_front_matter(readme) == EXPECTED_CARD_FRONT_MATTER,
+        "README model-card front matter mismatch",
+    )
+    readme_words = normalized_words(readme)
+    for required_text in (
+        MODEL_ID,
+        MODEL_REVISION,
+        ARTIFACT_SHA256,
+        EVALUATION_LENS_SHA256,
+        EVALUATION_ARTIFACT_SHA256,
+        "LICENSES/VIBETHINKER-LICENSE-NOTE.txt",
+        "The static site cannot analyze a new prompt.",
+        "50,050 readout rows",
+    ):
+        require(
+            required_text in readme_words,
+            f"README missing required binding: {required_text}",
+        )
+
+
+def validate_licenses_and_notices(root: Path) -> None:
+    notice = (root / "NOTICE").read_text(encoding="utf-8")
+    third_party = (root / "THIRD_PARTY_NOTICES.md").read_text(encoding="utf-8")
+    note = (root / "LICENSES/VIBETHINKER-LICENSE-NOTE.txt").read_text(encoding="utf-8")
+    qwen_license = (root / "LICENSES/QWEN-RESEARCH.txt").read_text(encoding="utf-8")
+    required_qwen_notice = (
+        "Qwen is licensed under the Qwen RESEARCH LICENSE AGREEMENT, "
+        "Copyright (c) Alibaba Cloud. All Rights Reserved."
+    )
+    require(
+        required_qwen_notice in normalized_words(notice),
+        "NOTICE is missing the required Qwen attribution",
+    )
+    require(
+        required_qwen_notice in normalized_words(qwen_license),
+        "Qwen license is missing its attribution clause",
+    )
+    require(
+        "Built with Qwen." in notice, "NOTICE is missing the Qwen product attribution"
+    )
+    require(
+        "LICENSES/VIBETHINKER-LICENSE-NOTE.txt" in notice
+        and "LICENSES/VIBETHINKER-LICENSE-NOTE.txt" in third_party,
+        "VibeThinker metadata note is not linked from the notices",
+    )
+    require(
+        "license: mit" in normalized_words(note),
+        "VibeThinker metadata declaration missing",
+    )
+    require(MODEL_REVISION in note, "VibeThinker metadata note revision mismatch")
+    require(
+        "It is not an upstream license text" in normalized_words(note),
+        "VibeThinker metadata note scope missing",
+    )
+    require(
+        not (root / "LICENSES" / ("VIBETHINKER-" + "MIT.txt")).exists(),
+        "removed VibeThinker license file is present",
+    )
+
+
+def validate_metadata_records(
+    config: dict[str, Any],
+    provenance: dict[str, Any],
+    frozen_validation: dict[str, Any],
+    evaluation: dict[str, Any],
+    evaluation_path: Path,
+) -> None:
+    require(config.get("schema_version") == 1, "config schema mismatch")
+    require(config.get("artifact_kind") == "jacobian_lens", "config kind mismatch")
+    require(config.get("d_model") == D_MODEL, "config width mismatch")
+    require(config.get("n_prompts") == 1000, "config prompt count mismatch")
+    require(
+        config.get("source_layers") == list(SOURCE_LAYERS),
+        "config source layers mismatch",
+    )
+    require(config.get("target_layer") == 35, "config target layer mismatch")
+    require(config.get("tensor_dtype") == "float16", "config tensor dtype mismatch")
+    require(
+        config.get("tensor_key_pattern") == "J.{source_layer}",
+        "config key pattern mismatch",
+    )
+    require(
+        config.get("model")
+        == {
+            "architecture": "Qwen2ForCausalLM",
+            "id": MODEL_ID,
+            "n_layers": 36,
+            "revision": MODEL_REVISION,
+        },
+        "config model binding mismatch",
+    )
+    require(
+        config.get("source_checkpoint", {}).get("sha256") == SOURCE_CHECKPOINT_SHA256,
+        "config source checkpoint mismatch",
+    )
+    require(
+        config.get("artifact")
+        == {
+            "filename": "model.safetensors",
+            "format": "safetensors",
+            "sha256": ARTIFACT_SHA256,
+            "size_bytes": ARTIFACT_SIZE_BYTES,
+        },
+        "config artifact binding mismatch",
+    )
+    require(
+        config.get("evaluation_artifact")
+        == {
+            "filename": "evaluation.safetensors",
+            "format": "safetensors",
+            "sha256": EVALUATION_ARTIFACT_SHA256,
+            "size_bytes": EVALUATION_ARTIFACT_SIZE_BYTES,
+            "source_checkpoint_sha256": EVALUATION_LENS_SHA256,
+            "tensor_conversion": "lossless_fp32_reserialization",
+            "tensor_dtype": "float32",
+        },
+        "config evaluation artifact binding mismatch",
+    )
+
+    require(provenance.get("schema_version") == 1, "provenance schema mismatch")
+    require(
+        provenance.get("model", {}).get("id") == MODEL_ID,
+        "provenance model ID mismatch",
+    )
+    require(
+        provenance.get("model", {}).get("revision") == MODEL_REVISION,
+        "provenance model revision mismatch",
+    )
+    require(
+        provenance.get("artifact", {}).get("sha256") == ARTIFACT_SHA256,
+        "provenance artifact hash mismatch",
+    )
+    require(
+        provenance.get("artifact", {}).get("size_bytes") == ARTIFACT_SIZE_BYTES,
+        "provenance artifact size mismatch",
+    )
+    require(
+        provenance.get("artifact", {}).get("tensor_conversion")
+        == "lossless_fp16_reserialization",
+        "provenance conversion boundary mismatch",
+    )
+    require(
+        provenance.get("source_checkpoint", {}).get("sha256")
+        == SOURCE_CHECKPOINT_SHA256,
+        "provenance source checkpoint mismatch",
+    )
+
+    require(frozen_validation.get("schema_version") == 1, "validation schema mismatch")
+    require(
+        frozen_validation.get("artifact") == "model.safetensors",
+        "validation filename mismatch",
+    )
+    require(
+        frozen_validation.get("artifact_sha256") == ARTIFACT_SHA256,
+        "validation artifact hash mismatch",
+    )
+    require(
+        frozen_validation.get("artifact_size_bytes") == ARTIFACT_SIZE_BYTES,
+        "validation artifact size mismatch",
+    )
+    require(frozen_validation.get("ok") is True, "frozen validation is not successful")
+    require(
+        frozen_validation.get("tensor_values_changed") == 0,
+        "frozen validation records changed values",
+    )
+    require(
+        frozen_validation.get("exact_tensor_matches") == len(SOURCE_LAYERS),
+        "frozen validation tensor count mismatch",
+    )
+    require(
+        frozen_validation.get("expected_tensor_matches") == len(SOURCE_LAYERS),
+        "frozen validation expected tensor count mismatch",
+    )
+    require(
+        frozen_validation.get("source_checkpoint_sha256") == SOURCE_CHECKPOINT_SHA256,
+        "frozen validation source checkpoint mismatch",
+    )
+    checks = frozen_validation.get("checks")
+    require(
+        isinstance(checks, dict)
+        and checks
+        and all(value is True for value in checks.values()),
+        "frozen validation contains a failed or malformed check",
+    )
+
+    require(
+        sha256_file(evaluation_path) == EVALUATION_FILE_SHA256,
+        "evaluation file hash mismatch",
+    )
+    require(
+        evaluation.get("artifact_kind") == "frozen_vibethinker_v1_readout_reference",
+        "evaluation artifact kind mismatch",
+    )
+    require(
+        evaluation.get("classification") == "validated_readout_only",
+        "evaluation classification mismatch",
+    )
+    require(evaluation.get("model") == MODEL_ID, "evaluation model ID mismatch")
+    require(
+        evaluation.get("model_revision") == MODEL_REVISION,
+        "evaluation model revision mismatch",
+    )
+    require(
+        evaluation.get("lens_sha256") == EVALUATION_LENS_SHA256,
+        "evaluation lens hash mismatch",
+    )
+    require(
+        evaluation.get("lens_variant") == "fp32_evaluation_safetensors_included",
+        "evaluation lens variant mismatch",
+    )
+    require(
+        evaluation.get("released_lens_artifact")
+        == {
+            "filename": "evaluation.safetensors",
+            "format": "safetensors",
+            "sha256": EVALUATION_ARTIFACT_SHA256,
+            "size_bytes": EVALUATION_ARTIFACT_SIZE_BYTES,
+            "source_checkpoint_sha256": EVALUATION_LENS_SHA256,
+            "tensor_conversion": "lossless_fp32_reserialization",
+        },
+        "evaluation released artifact binding mismatch",
+    )
+    require(
+        evaluation.get("claim_boundary") == EXPECTED_EVALUATION_CLAIM_BOUNDARY,
+        "evaluation claim boundary mismatch",
+    )
+    require(
+        evaluation.get("note") == EXPECTED_EVALUATION_NOTE,
+        "evaluation FP16/FP32 note mismatch",
+    )
+    require(
+        evaluation.get("selected_band") == list(SELECTED_BAND),
+        "evaluation selected band mismatch",
+    )
+    require(
+        evaluation.get("coverage_scope")
+        == "frozen_readout_source_run_not_the_100_prompt_ui_test_pack",
+        "evaluation coverage scope mismatch",
+    )
+    require(
+        evaluation.get("task_definition") == EXPECTED_EVALUATION_TASK,
+        "evaluation task definition mismatch",
+    )
+    evidence = evaluation.get("evidence", {})
+    require(
+        evidence.get("validated_readout_signal") is True,
+        "evaluation readout signal boundary mismatch",
+    )
+    require(
+        evidence.get("token_specific_vs_shuffled_target") is True,
+        "evaluation token control boundary mismatch",
+    )
+    require(
+        evidence.get("layer_mapping_specific_vs_shuffled_jacobian") is True,
+        "evaluation layer control boundary mismatch",
+    )
+    require(
+        evidence.get("incremental_over_ordinary_logit_lens") is False,
+        "evaluation logit-lens boundary mismatch",
+    )
+    require(
+        evidence.get("paired_bootstrap")
+        == {
+            "confidence": 0.95,
+            "input": "paired_item_metric_differences",
+            "interval": "percentile",
+            "metrics": ["pass@10", "mean_reciprocal_rank"],
+            "samples": 2000,
+            "scope": {
+                "kind": "selected_band",
+                "source_layers": list(SELECTED_BAND),
+            },
+            "split": "test",
+        },
+        "evaluation paired-bootstrap method mismatch",
+    )
+    require(
+        evidence.get("paired_bootstrap_decisions")
+        == {
+            "incremental_over_ordinary_logit_lens": {
+                "comparison": "jlens_band_minus_logit_lens_band",
+                "criterion": "at_least_one_lower_bound_greater_than_zero",
+                "met": False,
+            },
+            "layer_mapping_specific_vs_shuffled_jacobian": {
+                "comparison": "jlens_band_minus_shuffled_layer_band",
+                "criterion": "both_lower_bounds_greater_than_zero",
+                "met": True,
+            },
+            "token_specific_vs_shuffled_target": {
+                "comparison": "jlens_band_minus_shuffled_token_band",
+                "criterion": "both_lower_bounds_greater_than_zero",
+                "met": True,
+            },
+        },
+        "evaluation paired-bootstrap decisions mismatch",
+    )
+    require(
+        evidence.get("specificity_scope")
+        == {"kind": "selected_band", "source_layers": list(SELECTED_BAND)},
+        "evaluation specificity scope mismatch",
+    )
+    availability = evaluation.get("source_artifact_availability", {})
+    require(
+        availability
+        == {
+            "fp32_compatibility_check_output_included": True,
+            "fp32_compatibility_check_output_path": ("evaluation_compatibility.json"),
+            "fp32_derivation_record_included": True,
+            "fp32_derivation_record_path": "evaluation_provenance.json",
+            "fp32_evaluation_lens_included": True,
+            "fp32_evaluation_lens_path": "evaluation.safetensors",
+            "item_level_evaluation_rows_included": False,
+            "item_level_evaluation_rows_location": (
+                "companion_trace_repository:data/evaluation-results/"
+                "readout-trials.jsonl"
+            ),
+            "paired_bootstrap_interval_bounds_included": False,
+            "paired_bootstrap_interval_bounds_location": (
+                "companion_trace_repository:data/evaluation-results/"
+                "readout-bootstrap-intervals.json"
+            ),
+            "source_evaluation_bundle_included": False,
+            "source_hashes_included": True,
+            "source_hashes_location": (
+                "evaluation_provenance.json_and_companion_trace_repository:"
+                "data/readout-reference.json"
+            ),
+            "release_content": (
+                "fp16_trace_lens_fp32_evaluation_lens_aggregate_reference_"
+                "provenance_and_compatibility"
+            ),
+        },
+        "evaluation source-artifact boundary mismatch",
+    )
+    require(
+        EVALUATION_LENS_SHA256 != ARTIFACT_SHA256,
+        "FP32 and FP16 artifact hashes were conflated",
+    )
+
+
+def validate_tensor_manifest(manifest: dict[str, Any]) -> None:
+    require(
+        set(manifest)
+        == {
+            "artifact",
+            "artifact_sha256",
+            "artifact_size_bytes",
+            "schema_version",
+            "tensor_count",
+            "tensor_storage_bytes",
+            "tensors",
+        },
+        "tensor manifest top-level fields mismatch",
+    )
+    require(
+        manifest.get("artifact") == "model.safetensors",
+        "tensor manifest filename mismatch",
+    )
+    require(
+        manifest.get("artifact_sha256") == ARTIFACT_SHA256,
+        "tensor manifest artifact hash mismatch",
+    )
+    require(
+        manifest.get("artifact_size_bytes") == ARTIFACT_SIZE_BYTES,
+        "tensor manifest artifact size mismatch",
+    )
+    require(manifest.get("schema_version") == 1, "tensor manifest schema mismatch")
+    require(
+        manifest.get("tensor_count") == len(SOURCE_LAYERS),
+        "tensor manifest count mismatch",
+    )
+    require(
+        manifest.get("tensor_storage_bytes") == TENSOR_STORAGE_BYTES,
+        "tensor manifest storage total mismatch",
+    )
+    tensors = manifest.get("tensors")
+    require(isinstance(tensors, dict), "tensor manifest tensors must be an object")
+    require(set(tensors) == EXPECTED_KEYS, "tensor manifest key set mismatch")
+
+    recorded_storage = 0
+    for layer in SOURCE_LAYERS:
+        key = f"J.{layer}"
+        record = tensors[key]
+        require(isinstance(record, dict), f"{key} descriptor must be an object")
+        require(
+            set(record) == EXPECTED_TENSOR_RECORD_KEYS,
+            f"{key} descriptor fields mismatch",
+        )
+        require(record.get("source_layer") == layer, f"{key} source layer mismatch")
+        require(record.get("dtype") == "float16", f"{key} descriptor dtype mismatch")
+        require(
+            record.get("shape") == [D_MODEL, D_MODEL],
+            f"{key} descriptor shape mismatch",
+        )
+        require(
+            record.get("numel") == D_MODEL * D_MODEL,
+            f"{key} descriptor element count mismatch",
+        )
+        require(
+            record.get("nbytes") == TENSOR_NBYTES,
+            f"{key} descriptor byte count mismatch",
+        )
+        tensor_hash = record.get("sha256_c_contiguous_little_endian_bytes")
+        require(
+            isinstance(tensor_hash, str) and SHA256_PATTERN.fullmatch(tensor_hash),
+            f"{key} descriptor hash format mismatch",
+        )
+        recorded_storage += record["nbytes"]
+    require(
+        recorded_storage == TENSOR_STORAGE_BYTES,
+        "tensor descriptor byte total mismatch",
+    )
+
+
+def validate_evaluation_artifact(
+    root: Path,
+    manifest: dict[str, Any],
+    provenance: dict[str, Any],
+    frozen_validation: dict[str, Any],
+    compatibility: dict[str, Any],
+) -> int:
+    artifact_path = root / "evaluation.safetensors"
+    require(
+        set(manifest)
+        == {
+            "artifact",
+            "artifact_sha256",
+            "artifact_size_bytes",
+            "schema_version",
+            "source_checkpoint_sha256",
+            "tensor_count",
+            "tensor_storage_bytes",
+            "tensors",
+        },
+        "evaluation tensor manifest top-level fields mismatch",
+    )
+    require(
+        manifest.get("artifact") == "evaluation.safetensors",
+        "evaluation tensor manifest filename mismatch",
+    )
+    require(
+        manifest.get("artifact_sha256") == EVALUATION_ARTIFACT_SHA256,
+        "evaluation tensor manifest artifact hash mismatch",
+    )
+    require(
+        manifest.get("artifact_size_bytes") == EVALUATION_ARTIFACT_SIZE_BYTES,
+        "evaluation tensor manifest artifact size mismatch",
+    )
+    require(
+        manifest.get("source_checkpoint_sha256") == EVALUATION_LENS_SHA256,
+        "evaluation tensor manifest source hash mismatch",
+    )
+    require(
+        manifest.get("tensor_count") == len(SOURCE_LAYERS),
+        "evaluation tensor manifest count mismatch",
+    )
+    require(
+        manifest.get("tensor_storage_bytes") == EVALUATION_TENSOR_STORAGE_BYTES,
+        "evaluation tensor manifest storage total mismatch",
+    )
+    tensors = manifest.get("tensors")
+    require(isinstance(tensors, dict), "evaluation manifest tensors must be an object")
+    require(set(tensors) == EXPECTED_KEYS, "evaluation manifest key set mismatch")
+    for layer in SOURCE_LAYERS:
+        key = f"J.{layer}"
+        record = tensors[key]
+        require(
+            set(record) == EXPECTED_TENSOR_RECORD_KEYS,
+            f"evaluation {key} descriptor fields mismatch",
+        )
+        require(record.get("source_layer") == layer, f"evaluation {key} layer mismatch")
+        require(record.get("dtype") == "float32", f"evaluation {key} dtype mismatch")
+        require(
+            record.get("shape") == [D_MODEL, D_MODEL],
+            f"evaluation {key} shape mismatch",
+        )
+        require(
+            record.get("numel") == D_MODEL * D_MODEL,
+            f"evaluation {key} element count mismatch",
+        )
+        require(
+            record.get("nbytes") == EVALUATION_TENSOR_NBYTES,
+            f"evaluation {key} byte count mismatch",
+        )
+        require(
+            isinstance(record.get("sha256_c_contiguous_little_endian_bytes"), str)
+            and SHA256_PATTERN.fullmatch(
+                record["sha256_c_contiguous_little_endian_bytes"]
+            ),
+            f"evaluation {key} tensor hash format mismatch",
+        )
+
+    require(
+        provenance.get("artifact_kind") == "jacobian_lens_evaluation_fp32_provenance",
+        "evaluation provenance kind mismatch",
+    )
+    require(
+        provenance.get("artifact")
+        == {
+            "filename": "evaluation.safetensors",
+            "format": "safetensors",
+            "sha256": EVALUATION_ARTIFACT_SHA256,
+            "size_bytes": EVALUATION_ARTIFACT_SIZE_BYTES,
+            "tensor_conversion": "lossless_fp32_reserialization",
+        },
+        "evaluation provenance artifact binding mismatch",
+    )
+    require(
+        provenance.get("source_checkpoint")
+        == {"format": "pytorch", "sha256": EVALUATION_LENS_SHA256},
+        "evaluation provenance source binding mismatch",
+    )
+    derivation = provenance.get("derivation", {})
+    require(
+        derivation.get("formula") == "jacobian_sum[layer] / n_done",
+        "evaluation derivation formula mismatch",
+    )
+    require(derivation.get("n_done") == 1000, "evaluation derivation count mismatch")
+    require(
+        derivation.get("source_fit_checkpoint_sha256")
+        == EXPECTED_EVALUATION_METADATA["source_fit_checkpoint_sha256"],
+        "evaluation fit checkpoint binding mismatch",
+    )
+    require(
+        provenance.get("model", {}).get("id") == MODEL_ID
+        and provenance.get("model", {}).get("revision") == MODEL_REVISION,
+        "evaluation provenance model binding mismatch",
+    )
+    require(
+        provenance.get("lens", {}).get("dtype") == "float32"
+        and provenance.get("lens", {}).get("source_layers") == list(SOURCE_LAYERS)
+        and provenance.get("lens", {}).get("target_layer") == 35
+        and provenance.get("lens", {}).get("n_prompts") == 1000,
+        "evaluation provenance lens metadata mismatch",
+    )
+    runtime = provenance.get("software", {}).get("conversion_runtime", {})
+    require(
+        runtime.get("safetensors") == "0.8.0" and runtime.get("torch") == "2.13.0",
+        "evaluation conversion runtime mismatch",
+    )
+
+    require(
+        frozen_validation.get("artifact") == "evaluation.safetensors",
+        "evaluation validation filename mismatch",
+    )
+    require(
+        frozen_validation.get("artifact_sha256") == EVALUATION_ARTIFACT_SHA256,
+        "evaluation validation artifact hash mismatch",
+    )
+    require(
+        frozen_validation.get("artifact_size_bytes") == EVALUATION_ARTIFACT_SIZE_BYTES,
+        "evaluation validation artifact size mismatch",
+    )
+    require(
+        frozen_validation.get("source_checkpoint_sha256") == EVALUATION_LENS_SHA256,
+        "evaluation validation source hash mismatch",
+    )
+    require(frozen_validation.get("ok") is True, "evaluation validation failed")
+    require(
+        frozen_validation.get("tensor_values_changed") == 0,
+        "evaluation validation records changed values",
+    )
+    require(
+        frozen_validation.get("exact_tensor_matches") == len(SOURCE_LAYERS),
+        "evaluation validation tensor count mismatch",
+    )
+    checks = frozen_validation.get("checks")
+    require(
+        isinstance(checks, dict)
+        and checks
+        and all(value is True for value in checks.values()),
+        "evaluation validation contains a failed check",
+    )
+
+    require(
+        compatibility.get("artifact_kind") == "fp32_to_fp16_lens_compatibility",
+        "evaluation compatibility kind mismatch",
+    )
+    require(
+        compatibility.get("fp32_artifact") == "evaluation.safetensors"
+        and compatibility.get("fp32_artifact_sha256") == EVALUATION_ARTIFACT_SHA256
+        and compatibility.get("fp32_source_checkpoint_sha256")
+        == EVALUATION_LENS_SHA256,
+        "evaluation compatibility FP32 binding mismatch",
+    )
+    require(
+        compatibility.get("fp16_artifact") == "model.safetensors"
+        and compatibility.get("fp16_artifact_sha256") == ARTIFACT_SHA256,
+        "evaluation compatibility FP16 binding mismatch",
+    )
+    require(
+        compatibility.get("all_layer_casts_match_exactly") is True,
+        "evaluation compatibility records a cast mismatch",
+    )
+    require(
+        compatibility.get("max_absolute_error") == 0.00048828125,
+        "evaluation compatibility maximum error mismatch",
+    )
+    require(
+        math.isclose(
+            compatibility.get("relative_frobenius_error", math.inf),
+            0.00020901276774552773,
+            rel_tol=1e-12,
+            abs_tol=0.0,
+        ),
+        "evaluation compatibility relative error mismatch",
+    )
+    per_layer = compatibility.get("per_layer")
+    require(
+        isinstance(per_layer, dict)
+        and set(per_layer) == {str(layer) for layer in SOURCE_LAYERS},
+        "evaluation compatibility layer set mismatch",
+    )
+    require(
+        all(
+            record.get("cast_matches_model_safetensors_exactly") is True
+            for record in per_layer.values()
+        ),
+        "evaluation compatibility layer cast mismatch",
+    )
+
+    require(
+        sha256_file(artifact_path) == EVALUATION_ARTIFACT_SHA256,
+        "evaluation artifact SHA-256 mismatch",
+    )
+    require(
+        artifact_path.stat().st_size == EVALUATION_ARTIFACT_SIZE_BYTES,
+        "evaluation artifact size mismatch",
+    )
+    checked = 0
+    with (
+        safe_open(artifact_path, framework="pt", device="cpu") as artifact,
+        safe_open(
+            root / "model.safetensors", framework="pt", device="cpu"
+        ) as fp16_artifact,
+    ):
+        require(
+            (artifact.metadata() or {}) == EXPECTED_EVALUATION_METADATA,
+            "evaluation Safetensors metadata mismatch",
+        )
+        require(set(artifact.keys()) == EXPECTED_KEYS, "evaluation tensor key mismatch")
+        for layer in SOURCE_LAYERS:
+            key = f"J.{layer}"
+            tensor = artifact.get_tensor(key)
+            record = tensors[key]
+            require(tensor.dtype == torch.float32, f"evaluation {key} dtype mismatch")
+            require(
+                tuple(tensor.shape) == (D_MODEL, D_MODEL),
+                f"evaluation {key} shape mismatch",
+            )
+            require(tensor.is_contiguous(), f"evaluation {key} is not contiguous")
+            require(
+                bool(torch.isfinite(tensor).all()),
+                f"evaluation {key} contains non-finite values",
+            )
+            require(
+                tensor_sha256(tensor)
+                == record["sha256_c_contiguous_little_endian_bytes"],
+                f"evaluation {key} tensor hash mismatch",
+            )
+            require(
+                torch.equal(
+                    tensor.to(torch.float16).view(torch.int16),
+                    fp16_artifact.get_tensor(key).view(torch.int16),
+                ),
+                f"evaluation {key} FP16 cast mismatch",
+            )
+            checked += 1
+    return checked
+
+
+def run_git(root: Path, *arguments: str) -> subprocess.CompletedProcess[bytes]:
+    return subprocess.run(
+        ["git", "-C", str(root), *arguments],
+        check=False,
+        capture_output=True,
+    )
+
+
+def validate_git_lfs(
+    root: Path, *, require_evaluation_head: bool = False
+) -> tuple[bool, bool]:
+    repository_check = run_git(root, "rev-parse", "--is-inside-work-tree")
+    if repository_check.returncode != 0:
+        return False, False
+
+    model_pointer = (
+        "version https://git-lfs.github.com/spec/v1\n"
+        f"oid sha256:{ARTIFACT_SHA256}\n"
+        f"size {ARTIFACT_SIZE_BYTES}\n"
+    ).encode("ascii")
+    for object_name in ("HEAD:model.safetensors", ":model.safetensors"):
+        pointer = run_git(root, "show", object_name)
+        require(pointer.returncode == 0, f"cannot read Git LFS pointer: {object_name}")
+        require(
+            pointer.stdout == model_pointer, f"Git LFS pointer mismatch: {object_name}"
+        )
+
+    evaluation_pointer = (
+        "version https://git-lfs.github.com/spec/v1\n"
+        f"oid sha256:{EVALUATION_ARTIFACT_SHA256}\n"
+        f"size {EVALUATION_ARTIFACT_SIZE_BYTES}\n"
+    ).encode("ascii")
+    staged_evaluation = run_git(root, "show", ":evaluation.safetensors")
+    require(
+        staged_evaluation.returncode == 0,
+        "cannot read staged Git LFS pointer: evaluation.safetensors",
+    )
+    require(
+        staged_evaluation.stdout == evaluation_pointer,
+        "staged Git LFS pointer mismatch: evaluation.safetensors",
+    )
+    head_evaluation = run_git(root, "show", "HEAD:evaluation.safetensors")
+    if require_evaluation_head:
+        require(
+            head_evaluation.returncode == 0,
+            "publication check requires evaluation.safetensors in HEAD",
+        )
+    if head_evaluation.returncode == 0:
+        require(
+            head_evaluation.stdout == evaluation_pointer,
+            "Git LFS pointer mismatch: HEAD:evaluation.safetensors",
+        )
+
+    fsck = run_git(root, "lfs", "fsck", "HEAD")
+    require(fsck.returncode == 0, "git lfs fsck failed")
+    return True, True
+
+
+def validate(root: Path, *, require_publication_fields: bool = False) -> dict[str, Any]:
+    artifact_path = root / "model.safetensors"
+    readme = (root / "README.md").read_text(encoding="utf-8")
+    config = read_json(root / "lens_config.json")
+    manifest = read_json(root / "tensor_manifest.json")
+    provenance = read_json(root / "provenance.json")
+    frozen_validation = read_json(root / "validation.json")
+    evaluation_path = root / "evaluation.json"
+    evaluation = read_json(evaluation_path)
+    evaluation_manifest = read_json(root / "evaluation_tensor_manifest.json")
+    evaluation_provenance = read_json(root / "evaluation_provenance.json")
+    evaluation_validation = read_json(root / "evaluation_validation.json")
+    evaluation_compatibility = read_json(root / "evaluation_compatibility.json")
+
+    validate_release_file_set(root)
+    validate_pinned_public_files(root)
+    validate_public_text(root)
+    require(
+        (root / "requirements.txt").read_text(encoding="utf-8")
+        == "safetensors==0.8.0\ntorch==2.13.0\n",
+        "requirements do not match the evaluation conversion runtime",
+    )
+    validate_model_card(readme)
+    validate_licenses_and_notices(root)
+    validate_tensor_manifest(manifest)
+    evaluation_tensors_checked = validate_evaluation_artifact(
+        root,
+        evaluation_manifest,
+        evaluation_provenance,
+        evaluation_validation,
+        evaluation_compatibility,
+    )
+    validate_metadata_records(
+        config,
+        provenance,
+        frozen_validation,
+        evaluation,
+        evaluation_path,
+    )
+
+    publication_values, unresolved_publication_fields = parse_publication_rows(readme)
+    if require_publication_fields:
+        require(
+            not unresolved_publication_fields,
+            "publication fields remain unresolved: "
+            + ", ".join(unresolved_publication_fields),
+        )
+    if not unresolved_publication_fields:
+        validate_publication_values(publication_values)
+
+    expected_checksum_file = (
+        f"{ARTIFACT_SHA256}  model.safetensors\n"
+        f"{EVALUATION_ARTIFACT_SHA256}  evaluation.safetensors\n"
+    )
+    require(
+        (root / "SHA256SUMS").read_text(encoding="ascii") == expected_checksum_file,
+        "SHA256SUMS content mismatch",
+    )
+    artifact_checksum = sha256_file(artifact_path)
+    require(artifact_checksum == ARTIFACT_SHA256, "artifact SHA-256 mismatch")
+    require(
+        artifact_path.stat().st_size == ARTIFACT_SIZE_BYTES, "artifact size mismatch"
+    )
+
+    checked = 0
+    with safe_open(artifact_path, framework="pt", device="cpu") as artifact:
+        require(
+            (artifact.metadata() or {}) == EXPECTED_METADATA,
+            "safetensors metadata mismatch",
+        )
+        require(
+            set(artifact.keys()) == EXPECTED_KEYS, "safetensors tensor key mismatch"
+        )
+        for layer in SOURCE_LAYERS:
+            key = f"J.{layer}"
+            tensor = artifact.get_tensor(key)
+            record = manifest["tensors"][key]
+            require(tensor.dtype == torch.float16, f"{key} dtype mismatch")
+            require(tuple(tensor.shape) == (D_MODEL, D_MODEL), f"{key} shape mismatch")
+            require(tensor.is_contiguous(), f"{key} is not contiguous")
+            require(
+                bool(torch.isfinite(tensor).all()), f"{key} contains non-finite values"
+            )
+            require(tensor.numel() == record["numel"], f"{key} element count mismatch")
+            require(
+                tensor.numel() * tensor.element_size() == record["nbytes"],
+                f"{key} byte count mismatch",
+            )
+            require(
+                tensor_sha256(tensor)
+                == record["sha256_c_contiguous_little_endian_bytes"],
+                f"{key} tensor hash mismatch",
+            )
+            checked += 1
+
+    lfs_pointer_exact, lfs_fsck_ok = validate_git_lfs(
+        root,
+        require_evaluation_head=require_publication_fields,
+    )
+    if require_publication_fields:
+        require(
+            lfs_pointer_exact and lfs_fsck_ok,
+            "publication check requires Git LFS validation",
+        )
+
+    return {
+        "artifact": artifact_path.name,
+        "artifact_kind": EXPECTED_METADATA["artifact_kind"],
+        "artifact_sha256": artifact_checksum,
+        "artifact_size_bytes": artifact_path.stat().st_size,
+        "evaluation_artifact_separation": True,
+        "evaluation_artifact_sha256": EVALUATION_ARTIFACT_SHA256,
+        "evaluation_artifact_size_bytes": EVALUATION_ARTIFACT_SIZE_BYTES,
+        "evaluation_lens_sha256": EVALUATION_LENS_SHA256,
+        "evaluation_tensor_count": evaluation_tensors_checked,
+        "fp32_to_fp16_cast_exact": True,
+        "license_notice_hashes_exact": True,
+        "lfs_fsck_ok": lfs_fsck_ok,
+        "lfs_pointer_exact": lfs_pointer_exact,
+        "metadata_exact": True,
+        "model_binding_exact": True,
+        "ok": (
+            checked == len(EXPECTED_KEYS)
+            and evaluation_tensors_checked == len(EXPECTED_KEYS)
+        ),
+        "privacy_text_scan": True,
+        "publication_fields_resolved": not unresolved_publication_fields,
+        "release_file_set_exact": True,
+        "tensor_count": checked,
+        "tensor_descriptors_exact": True,
+        "tensor_hashes_exact": True,
+        "unresolved_publication_fields": unresolved_publication_fields,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--root",
+        type=Path,
+        default=Path(__file__).resolve().parents[1],
+        help="Artifact repository root",
+    )
+    parser.add_argument(
+        "--publication",
+        action="store_true",
+        help="Require resolved and valid companion publication fields",
+    )
+    args = parser.parse_args()
+    try:
+        result = validate(
+            args.root.resolve(),
+            require_publication_fields=args.publication,
+        )
+    except ValueError as error:
+        parser.error(str(error))
+    print(
+        json.dumps(
+            result,
+            indent=2,
+            sort_keys=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

tensor_manifest.json

@@ -0,0 +1,208 @@
+{
+  "artifact": "model.safetensors",
+  "artifact_sha256": "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c",
+  "artifact_size_bytes": 150996824,
+  "schema_version": 1,
+  "tensor_count": 18,
+  "tensor_storage_bytes": 150994944,
+  "tensors": {
+    "J.0": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "70b0dec033aa1707f047f17b9149ed137431e86b17958bd4a7e48d50fdda3d51",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 0
+    },
+    "J.10": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "30da4128931002f756acb8f26c7a807b0a03aae37ebd5d1fce859ca8872203fe",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 10
+    },
+    "J.12": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "1585c024e196065636ace0c6693304b5d238589b778d8469975cb735cac4a58e",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 12
+    },
+    "J.14": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "25474372408e43f00aa30c8787e0953b56674d84a3d4e110619c8122de6939fc",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 14
+    },
+    "J.16": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "f8451021c23b81883bed655568aaf5fb91fcbf0ef5abe5f92400df8012f759c9",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 16
+    },
+    "J.18": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "8af4ab11ea1c9443b0e6ba6abf0af5073032b8c4eced8365b6a3c5ea10ec32ba",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 18
+    },
+    "J.2": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "8a8bc773b72f5bb7e697700ba780ba105fb3efa5c966ff90121f12f97e4eb601",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 2
+    },
+    "J.20": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "714121ea97b8bb8ba6d72b9656dfbb33e777f2345f0c990494c8960cfa493c77",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 20
+    },
+    "J.22": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "ea197cfe6095e67364ef2d88a44fb07c80b7731c78d1137c7372771902ddf784",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 22
+    },
+    "J.24": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "2f0e30882300a6914fd9bc089b1b038beda30e4ed1eca0da0051a532eb367c70",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 24
+    },
+    "J.26": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "e5b3789b2802efb00d9e2e3e2753059e16db80ebef26c9e363e8a43f1a08f3da",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 26
+    },
+    "J.28": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "de9fd5a978c691d30c46289fa179332cee671f69aba8c4442d7f61382cd56e40",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 28
+    },
+    "J.30": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "143d3abe3632641ab2bb6b2c0582ef9d461e0b144b1a29f1f67e716645ea5f4c",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 30
+    },
+    "J.32": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "bbb1664e19ef450f68a8202c7c6007633e160c96712866c3793cb80474f589dc",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 32
+    },
+    "J.34": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "a2745b1142ae10a8b7fd449eba62e5530216c4026c748aed78eda69b7aeb35f9",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 34
+    },
+    "J.4": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "c4970a9604879056b2f4493b1e8b1b0401ae115c236613b37875edf991425cdd",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 4
+    },
+    "J.6": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "57e34398437bd673ecfe10b8c696306a706287d18307edceb4b69bf1fced1905",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 6
+    },
+    "J.8": {
+      "dtype": "float16",
+      "nbytes": 8388608,
+      "numel": 4194304,
+      "sha256_c_contiguous_little_endian_bytes": "dfecda781a5e26a3573a7c7f8ff8dc173bc4b55c6e6f1a80b3c7a918d08eece6",
+      "shape": [
+        2048,
+        2048
+      ],
+      "source_layer": 8
+    }
+  }
+}

validation.json

@@ -0,0 +1,28 @@
+{
+  "artifact": "model.safetensors",
+  "artifact_sha256": "089d776979408f23e5377539c15aa8025d171633718ccdce709bcd3372e7942c",
+  "artifact_size_bytes": 150996824,
+  "checks": {
+    "all_source_tensors_contiguous": true,
+    "all_source_tensors_finite": true,
+    "all_source_tensors_fp16": true,
+    "all_source_tensors_shape_2048x2048": true,
+    "roundtrip_all_tensor_bit_patterns_equal": true,
+    "roundtrip_all_tensor_byte_hashes_equal": true,
+    "roundtrip_all_tensor_dtypes_equal": true,
+    "roundtrip_all_tensor_shapes_equal": true,
+    "roundtrip_all_tensor_values_equal": true,
+    "roundtrip_key_set_exact": true,
+    "safetensors_header_public_safe": true,
+    "safetensors_header_roundtrip_exact": true,
+    "source_checkpoint_sha256_exact": true,
+    "source_metadata_exact": true,
+    "source_top_level_key_set_exact": true
+  },
+  "exact_tensor_matches": 18,
+  "expected_tensor_matches": 18,
+  "ok": true,
+  "schema_version": 1,
+  "source_checkpoint_sha256": "f36a99447623e0d777c70951a9148a7a52e42e0df82942e22ce6326f63d8d664",
+  "tensor_values_changed": 0
+}