Publish Jeeves MLX 4bit (CPU diagnostics; not benchmarked)

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

BUILD.md

@@ -0,0 +1,90 @@
+# Build and publication record
+
+## Conversion is not training
+
+These already-converted `4bit` weights were read from the user's completed `jeeves_9b_cpu_v1_1` build. The publishing notebook does not train, merge adapters, reconvert, quantize, run inference, recalibrate, or change model tensors. It streams existing files from Drive.
+
+The upstream release describes fused Qwen3.5-9B weights, a pointer head, and a fitted temperature. See the [original code](https://github.com/PostHog/jeeves) and [original model card](https://huggingface.co/PostHog/jeeves) for the upstream training recipe; no new training performance is asserted here.
+
+## Pinned conversion inputs
+
+```json
+{
+  "request": {
+    "schema": "jeeves-mlx-cpu-v1",
+    "repo_id": "PostHog/jeeves",
+    "hf_revision": "8622b7d1652a9dcb8629486b84dce9e8d690c5cd",
+    "jeeves_code_ref": "HEAD",
+    "mlx_lm_code_ref": "refs/heads/main",
+    "mlx_requirement": "mlx[cpu]==0.32.3",
+    "quant_bits": [
+      4,
+      8
+    ],
+    "q_group_size": 64,
+    "run_torch_reference": true,
+    "run_cpu_smoke": true,
+    "smoke_cases": 1,
+    "smoke_max_tokens": 256,
+    "prefill_chunk_size": 16,
+    "greedy_smoke_tokens": 0,
+    "min_ram_gib": 24,
+    "bf16_probability_atol": 0.02,
+    "bf16_min_cosine": 0.995,
+    "helper_sha256": {
+      "jeeves_support.py": "26ca899ee62b13ef3a93ff7075bf4fcfd097e1c1e15589b667c22be71205beb6",
+      "run_jeeves.py": "5e381f42611ee195f4579eb3d3433abf7c292aecb26e52b6ccd94ecd4e13c654",
+      "convert_worker.py": "538444544ae39fdbe5031b0a75dcff88615b33e1127d7eb42fefde325c36afd7"
+    }
+  },
+  "jeeves_code_sha": "f04ec5567301450dcaae0210dd54deeb4f647f87",
+  "mlx_lm_sha": "94cdcae13b266c337bcaca09b97b9c5a9c0e2cde",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa"
+}
+```
+
+This is the original conversion lock, not the publishing environment. The original Mac dependencies are in `requirements-mac.txt`. The CPU dependency lock is included in `provenance/requirements-cpu-lock.txt` when present in the original run. These pins identify the build; this document is not a substitute for a complete conversion implementation.
+
+## Stored converted configuration
+
+```json
+{
+  "model_type": "qwen3_5",
+  "num_hidden_layers": 32,
+  "hidden_size": 4096,
+  "full_attention_interval": 4,
+  "rope_theta": 10000000,
+  "partial_rotary_factor": 0.25,
+  "rope_parameters": {
+    "type": "default",
+    "rope_theta": 10000000,
+    "partial_rotary_factor": 0.25
+  },
+  "quantization": {
+    "group_size": 64,
+    "bits": 4,
+    "mode": "affine"
+  },
+  "quantization_config": {
+    "group_size": 64,
+    "bits": 4,
+    "mode": "affine"
+  }
+}
+```
+
+The retained `provenance/source_config.json`, source shard hashes, original encoder/head source, and audit records describe the conversion inputs. The published backbone uses MLX tensor layout and `model_type=qwen3_5`; the pointer head is separately stored in FP32. Original `head.pt` is retained for provenance and is never unpickled by the publishing notebook.
+
+## What publication verifies
+
+The publisher checks every original manifest entry using streaming full-file SHA-256; reads `validation.json`; checks required licenses/runner/tokenizer/head files; validates safetensors headers, offsets, and shard indexing without loading tensors; checks expected quantization metadata and cross-variant shared files; scans text/code files for common credential patterns; then constructs a new release manifest. A credential scan is a safeguard, not a general audit of private content.
+
+Only files named in the verified package manifest and the explicitly generated release documents are eligible for upload. Caches, secrets, unrelated Drive files, raw run logs, and undeclared files are not uploaded. No model-weight copy is made on Drive or in a staging folder.
+
+Uploads use explicit file paths and a parent-commit guard. Existing managed branch contents are compared by size plus LFS SHA-256 or regular Git-blob SHA-1. Unexpected files or an unrelated existing repository cause a stop, not an automatic deletion. Successful upload verification checks Hub file metadata at an immutable commit and downloads `validation.json` for byte comparison; it does not re-download all weights or execute them.
+
+`provenance/original_package_README.md` and `provenance/source_PACKAGE_MANIFEST.json` preserve the originals. New `README.md`, `BUILD.md`, `RELEASE.json`, and `PACKAGE_MANIFEST.json` document the publication; `validation.json`, runtime code, weights, tokenizer, calibration, and licenses remain byte-identical to the conversion package. The root published manifest excludes itself by design.
+
+## Remaining validation
+
+Apple Metal execution, representative task accuracy, calibration after quantization, greedy reasoning, and realistic latency/memory benchmarks remain unmeasured. Packaging and remote checksum checks must not be reported as model-quality validation.

CONVERSION_COMPLETE.json

@@ -0,0 +1,8 @@
+{
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "variant": "jeeves-mlx-4bit",
+  "tensor_count": 927,
+  "tensor_bytes": 5038040064,
+  "status": "weights_converted_and_structurally_checked",
+  "backbone_parity": "not_yet_assessed"
+}

LICENSE

@@ -0,0 +1,202 @@
+
+                                 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 2026 Alibaba Cloud
+
+   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.

LICENSE_JEEVES_CODE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicholas P. Waltz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PACKAGE_MANIFEST.json

@@ -0,0 +1,224 @@
+{
+  "conversion_identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "files": {
+    "BUILD.md": {
+      "bytes": 4914,
+      "git_blob_sha1": "9befdd51c6eab46dbaaa30e80cdfcd1a8bb73914",
+      "sha256": "54a936dac8c11112c82ef931a4115b3887b0e353e64038058a334508e908244e"
+    },
+    "CONVERSION_COMPLETE.json": {
+      "bytes": 269,
+      "git_blob_sha1": "3bbdb56b348f87fc20d006204624e8d559c402a3",
+      "sha256": "cb7ff21cfa818a070dc01cb79829ceca9e293e5c9dfc400ab8c8a81a4699b383"
+    },
+    "LICENSE": {
+      "bytes": 11544,
+      "git_blob_sha1": "f938136e3adacfd92be087f6e113b5d6d97f678f",
+      "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a"
+    },
+    "LICENSE_JEEVES_CODE": {
+      "bytes": 1074,
+      "git_blob_sha1": "f86d38990a659f4df8800a78a48744e18908e7ca",
+      "sha256": "823f556c20700f9a2f5e520c7d4eb3089f083fb19cf618cdbe08c08982f41b8e"
+    },
+    "README.md": {
+      "bytes": 6654,
+      "git_blob_sha1": "94ae7402fb520e1c273858b59c834738871f1c5d",
+      "sha256": "afca0915c4c0f884953f333b3f7af88a6aa7f62a171b487cd5ddceb3fe6fab5c"
+    },
+    "RELEASE.json": {
+      "bytes": 647,
+      "git_blob_sha1": "ce36b81379680de18edc1be0b9f7081d4f1d21d2",
+      "sha256": "a024d878ea83db6b976c2896cfc5bcd860e7ddd70255ef7c2095af946c11f86f"
+    },
+    "chat_template.jinja": {
+      "bytes": 7756,
+      "git_blob_sha1": "a585dec894e63da457d9440ec6aa7caa16d20860",
+      "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715"
+    },
+    "config.json": {
+      "bytes": 2080,
+      "git_blob_sha1": "d43ddf5fab8169d39664c06156eae65e41d13af2",
+      "sha256": "6cc3a4bc9bd804159d7849476564026451ace6009b7fc51cdf14908aaacf333a"
+    },
+    "dataformat.py": {
+      "bytes": 6058,
+      "git_blob_sha1": "c950dadc457b051e03aa19eabd25aec299b93899",
+      "sha256": "1c421b0e2ba879f5799842b3a44350d1f1db117ead23c47c7b01a27e2139c664"
+    },
+    "example_request.json": {
+      "bytes": 179,
+      "git_blob_sha1": "7fcfe2a8fd726bb73afe68d98be985f4e7ba790a",
+      "sha256": "7cec13b2283352be787736c7bb47fb783b61814f9ed25fb9ac2742d521435145"
+    },
+    "export.json": {
+      "bytes": 2582,
+      "git_blob_sha1": "cd254ec10c3a8eff3bbe52d42f88e20564c56721",
+      "sha256": "608d8aa594bc9cc6cd37e691eb3b5ec0e661866be0ae38f21659f6d70531e8a1"
+    },
+    "fixtures.json": {
+      "bytes": 4863,
+      "git_blob_sha1": "d1afbc455f04bd8648a0c823ad0c7ff56e0c3c3c",
+      "sha256": "2887c941fd5a497ae51343a9e2382ea1d198ab5eb140f4e8c8fd37c54be4ebf0"
+    },
+    "head.pt": {
+      "bytes": 8392767,
+      "git_blob_sha1": "48bc4d58231ee305e7d3bd9b719ef47ff8ab328f",
+      "sha256": "2ab935dea9eecf263086d9ed6dfe97fd5558193663ecae102fd3c50ae6878d60"
+    },
+    "head.safetensors": {
+      "bytes": 8391016,
+      "git_blob_sha1": "837f2da3c17a936f5347529ef7c421c8ab08ef4d",
+      "sha256": "ceac931470abafbc62723a297291f2c3d96627679794433585e658981798343e"
+    },
+    "jeeves_format.py": {
+      "bytes": 4244,
+      "git_blob_sha1": "1904b0a300b93f944d463722a3864827b8a6e38c",
+      "sha256": "6bb9599483ce4328024bf2c8473959996b3c55a226ae2a31c739ec87b0f215ca"
+    },
+    "jeeves_support.py": {
+      "bytes": 7920,
+      "git_blob_sha1": "7ed1ca6a65b11ee078f4f202296480cbb481c29b",
+      "sha256": "26ca899ee62b13ef3a93ff7075bf4fcfd097e1c1e15589b667c22be71205beb6"
+    },
+    "model.safetensors": {
+      "bytes": 5038161163,
+      "git_blob_sha1": "416a53edc10b90b36a80b9bab618a59d19abba24",
+      "sha256": "a7f3c503106f38d7bff3a55cb16b82bb5085fd8247893ade8a1de6ed1750e1f1"
+    },
+    "model.safetensors.index.json": {
+      "bytes": 81194,
+      "git_blob_sha1": "a155f5eba81d28e47c41d1522c5fbaefed63f19d",
+      "sha256": "215f9abadc1cea4d465b01c036dffcac5a84c2fb2386777863eff6928b91ed0b"
+    },
+    "provenance/bf16_weight_audit.json": {
+      "bytes": 201,
+      "git_blob_sha1": "b181d091a68d1bd2407c6d3d18d36e4de27867e0",
+      "sha256": "a4668cfbcf61c2946e870e552776d876f8cfd1cd021b4bda5f30795bfa545ee4"
+    },
+    "provenance/conversion_run_lock.json": {
+      "bytes": 1113,
+      "git_blob_sha1": "23670a4c65c17b7240f4381af793d04f28b71186",
+      "sha256": "ee800d671e63a5f3008b91e633353ad27f25d3980a877a82575febd41349fd47"
+    },
+    "provenance/format_head_checks.json": {
+      "bytes": 481,
+      "git_blob_sha1": "34e60904788736db8e14dd4d173c078c5bb31ea6",
+      "sha256": "fb3c9913a7d9200186d9b4ec7e79701e1b9fb0e9513636e7b84db716584140ce"
+    },
+    "provenance/jeeves-mlx-4bit.npz": {
+      "bytes": 49972,
+      "git_blob_sha1": "fef4ffe75c32a3b85bd6551dac62eebf8d8ece85",
+      "sha256": "b23046076e0105c29e487312856067b9e4c0a4d53ced30a543b5543911551ba7"
+    },
+    "provenance/jeeves-mlx-4bit_smoke.json": {
+      "bytes": 467,
+      "git_blob_sha1": "565aec925f5924d6549c7d4cae5e87c41ee3be53",
+      "sha256": "4f76a693cf949f7cdd3eac7b573b8e15083e5a3f0b7614a06ec449a525c05baf"
+    },
+    "provenance/jeeves-mlx-bf16.npz": {
+      "bytes": 49972,
+      "git_blob_sha1": "de5830dda85c898a36c7c7b1d858f63307107d84",
+      "sha256": "20f08bc1b539c2b7321c666c73faba142141641db0c27757958a1f463e92f52c"
+    },
+    "provenance/jeeves-mlx-bf16_smoke.json": {
+      "bytes": 469,
+      "git_blob_sha1": "73d8c5abc70344b4f73fadfc59913abc1524388a",
+      "sha256": "09b6e75e09a1b51d571e0309e9de7f566b33a5aa86fa039a5669577717dade0d"
+    },
+    "provenance/original_package_README.md": {
+      "bytes": 2192,
+      "git_blob_sha1": "36d1319d9e35e6cac375ee2d4e4e5cee2563e285",
+      "sha256": "fc5140a87a684cb672186d46c739e8482174854632dbcb929985ffda6eced3a9"
+    },
+    "provenance/preflight.json": {
+      "bytes": 337,
+      "git_blob_sha1": "09ccfb8117071b61d962cb9e7f6e7e1643f69af9",
+      "sha256": "6cc3ab0b1b759f6751f68ca3867f9648573a69e9632840feb42cb2b60daf27c6"
+    },
+    "provenance/requirements-cpu-lock.txt": {
+      "bytes": 750,
+      "git_blob_sha1": "9bf3f6068366175d8f20e5d84aa1098067459f7d",
+      "sha256": "3001f76ad1dea715696448e5cc7bfbb52a44291e09fae27b65bcc3eaf3bfecb5"
+    },
+    "provenance/source_PACKAGE_MANIFEST.json": {
+      "bytes": 5445,
+      "git_blob_sha1": "101d33c375185a8fedc7257373c6795ba37da2af",
+      "sha256": "f1559f8e86c02d9544f9bbded27d8df5425ae8fc700a32271038e1495ef69279"
+    },
+    "provenance/source_config.json": {
+      "bytes": 1471,
+      "git_blob_sha1": "6902ebcb645647c0f9bc61274442c665e75e0880",
+      "sha256": "b0ca5d0cb2056e4c1a4eb9a0616c114773cbd8b7428c1927259b28b3938b4191"
+    },
+    "provenance/source_lock.json": {
+      "bytes": 302,
+      "git_blob_sha1": "3dc183e04a66d8338c427d2f63c060b06757fd2c",
+      "sha256": "d96f01e2558461e3c3daa874755a8212af64591840f6e6c8415f73ad8328e446"
+    },
+    "provenance/source_shards.json": {
+      "bytes": 913,
+      "git_blob_sha1": "2fbeaff8dd643a41bd1b828f747288e5b64a5ba9",
+      "sha256": "8f7b5da3ef9b11a19ff1976b382fc5908989beab726c68ad8ef70b6db7c57f8e"
+    },
+    "provenance/torch_reference.json": {
+      "bytes": 504,
+      "git_blob_sha1": "9842d7ba5524ff558c3d61a081f4e818e122be80",
+      "sha256": "1ff8eed755e0c8d4febb490a8be902c4b21a33802e428ff23047a31109d41c8c"
+    },
+    "provenance/torch_reference.npz": {
+      "bytes": 49972,
+      "git_blob_sha1": "1ec661cbef5fc938a76228bf1f6bd2450e9aac23",
+      "sha256": "852fadb6c779fbbb45073590aa5f08f6385f903dad22c8a6ab27d6613de5ebba"
+    },
+    "provenance/upstream_code.json": {
+      "bytes": 799,
+      "git_blob_sha1": "73dd0d880b5cab190c16e1ad5bb50f2761357ab6",
+      "sha256": "d50143f13dac140feb845dfef53380e370371f6c95412bee6b212d5387bb7987"
+    },
+    "provenance/upstream_dataloader.py": {
+      "bytes": 11424,
+      "git_blob_sha1": "1fcb0ead744abd3cddf413f8a636497a4908549e",
+      "sha256": "7d8a43ddcac427125bbe6b8aca9cfb3306aa1dbef6d7509bfed1a65a2d93b4d1"
+    },
+    "provenance/upstream_head.py": {
+      "bytes": 714,
+      "git_blob_sha1": "93dbcbf2adf466764da93fd63456d272f4ba8b70",
+      "sha256": "4c4f503c0ecef50d58b7a789f79f9336324c1548d9832e9ce75a675fd2ba302f"
+    },
+    "provenance/upstream_model_card.md": {
+      "bytes": 5234,
+      "git_blob_sha1": "406793bf53d745ecf44940d7ba21c8b340ae3e0d",
+      "sha256": "8f18acc423edf4c7db50d877f8f826ff6e019e6395092b800b6673db3e00cae2"
+    },
+    "requirements-mac.txt": {
+      "bytes": 184,
+      "git_blob_sha1": "0ea05364a02bff105cc85d094481bf18e13f9281",
+      "sha256": "01b04c2acde4835455b18b65e8e3567c1a8d607f23692afb01f4a842487dd147"
+    },
+    "run_jeeves.py": {
+      "bytes": 9594,
+      "git_blob_sha1": "9c6b9e9e062968776758a645ef6c5b67c0c85df8",
+      "sha256": "5e381f42611ee195f4579eb3d3433abf7c292aecb26e52b6ccd94ecd4e13c654"
+    },
+    "tokenizer.json": {
+      "bytes": 19989325,
+      "git_blob_sha1": "d5967dbafffa6c5b250a02b35723f53e702d0d62",
+      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
+    },
+    "tokenizer_config.json": {
+      "bytes": 1161,
+      "git_blob_sha1": "8d610519919e32dd25f499e61f4bd38d7a0ad9b2",
+      "sha256": "95c557768e6b88a7128befc7bfd3c7de50e5d51af9b8b33a9f4dee0e04f99679"
+    },
+    "validation.json": {
+      "bytes": 2250,
+      "git_blob_sha1": "cd87a7cb8c9203e61b7b816d3ec96f5e2a76c4b1",
+      "sha256": "36d3a8cf620c7db74476f8f4f6d0c8ab77b225bb0d6b5c8859eb0d5bf57f5061"
+    }
+  },
+  "repo_id": "cowWhySo/jeeves-mlx",
+  "schema": "cowwhyso-jeeves-mlx-publisher/v1",
+  "self_excluded": "PACKAGE_MANIFEST.json",
+  "variant": "4bit"
+}

README.md

@@ -0,0 +1,89 @@
+---
+license: apache-2.0
+language:
+- en
+base_model: PostHog/jeeves
+library_name: mlx
+pipeline_tag: text-classification
+tags:
+- mlx
+- qwen3.5
+- decision
+- unofficial-port
+- experimental
+- 4bit
+---
+
+# Jeeves-9B MLX — 4bit
+
+Unofficial CPU-converted MLX packaging of **[PostHog/jeeves](https://huggingface.co/PostHog/jeeves)**, published by **[cowWhySo](https://huggingface.co/cowWhySo)**. This is not a PostHog or Apple release, a newly trained model, or a benchmark-certified port.
+
+**Original project: [PostHog/jeeves on GitHub](https://github.com/PostHog/jeeves)**  
+**Original model: [PostHog/jeeves on Hugging Face](https://huggingface.co/PostHog/jeeves)**
+
+> **Validation: `converted_and_small_cpu_diagnostics_passed_not_benchmarked`.** Read [validation.json](validation.json) before relying on the package. Apple Metal execution, task accuracy, post-quantization calibration, and representative latency remain unmeasured. Upstream benchmark scores and CUDA speed claims do not transfer to this conversion.
+
+## Available packages
+
+One repository; one complete package per branch. `main` contains **4-bit**, not BF16. Other variants are branches, not subfolders. Downloading one revision does not download the others.
+
+| Variant | Revision | Original package size on Drive |
+| --- | --- | ---: |
+| 4bit | [`main`](https://huggingface.co/cowWhySo/jeeves-mlx/tree/main) | 4.73 GiB |
+| 8bit | [`8bit`](https://huggingface.co/cowWhySo/jeeves-mlx/tree/8bit) | 8.90 GiB |
+| bf16 | [`bf16`](https://huggingface.co/cowWhySo/jeeves-mlx/tree/bf16) | 16.71 GiB |
+
+Sizes are actual original package bytes divided by 2^30 (GiB), including auxiliary files. Publishing adds small documentation/manifest files. These are **disk sizes**, not measured peak RAM or unified-memory requirements. This README describes the `main` revision.
+
+## What is preserved
+
+The Qwen3.5-9B backbone uses **4-bit MLX affine quantization, group size 64**. The original pointer head is retained as `head.pt` and exported without changing its FP32 values as `head.safetensors`. The released fitted temperature is **1.85892808437347**, retained in `export.json`; it has **not** been refitted for quantization. Exact-format helpers, the tokenizer, original licenses, source records, and diagnostic fixtures accompany the weights.
+
+Jeeves uses a custom decision head and prompt/readout format, not an ordinary text-generation pipeline. Use the included `run_jeeves.py` for decisions; `mlx_lm.generate` alone does not implement Jeeves scoring. See [BUILD.md](BUILD.md) for build details and [provenance/original_package_README.md](provenance/original_package_README.md) for the original conversion notes.
+
+## Download and try on Apple Silicon
+
+These are **instructions for an unmeasured Metal path**, not a claim that this release has been tested on a Mac. Review the included Python source before running it. Each variant should have its own local directory; do not overlay variants into one directory.
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install "huggingface_hub==1.33.0"
+hf download cowWhySo/jeeves-mlx --revision main --local-dir jeeves-mlx-4bit
+cd jeeves-mlx-4bit
+python -m pip install -r requirements-mac.txt
+python run_jeeves.py --model . --request example_request.json --device gpu --think-tokens 0
+```
+
+To select a different variant, replace the revision and directory with `main` / `jeeves-mlx-4bit`, `8bit` / `jeeves-mlx-8bit`, or `bf16` / `jeeves-mlx-bf16`. Pin a release commit SHA instead of a branch for reproducible downstream experiments.
+
+The runner accepts `state` and a `questions` mapping with `noul`, `choice`, or `score` types. It returns option probabilities under its own `results` schema; it is **not wire-compatible** with the upstream `/v1/systemone` HTTP service.
+
+An optional, **unvalidated greedy-thinking path** exists:
+
+```bash
+python run_jeeves.py --model . --request example_request.json --device gpu --think-tokens 128
+```
+
+The reference runner processes questions independently, uses a separate cache per question, and re-prefills the full sequence for decision readout after optional reasoning. It does not port the speculative diffusion drafters, CUDA graphs, FP8 serving, parallel-question engine, or adaptive no-thinking threshold.
+
+## Evidence and limits
+
+The stored format/head checks passed for 4 format cases. The synthetic-hidden-state pointer-head comparison reported maximum probability error 0; it is **not** a backbone comparison. The stored no-thinking CPU smoke test contains **1 case(s)**. The BF16 backbone comparison is explicitly a small-fixture diagnostic with heuristic tolerances, not general equivalence.
+
+On the recorded 1-case diagnostic, the maximum option-probability difference from MLX BF16 was 0.016297996. This is not an accuracy or calibration estimate.
+
+No task accuracy, calibration benchmark, Metal speed, quantized quality ranking, or validated reasoning performance is claimed. CPU smoke elapsed times in the evidence are diagnostics, not representative serving benchmarks. Retaining the original temperature is not evidence of calibration on a different numerical path.
+
+## Build provenance
+
+- Model source: [`PostHog/jeeves@8622b7d1652a9dcb8629486b84dce9e8d690c5cd`](https://huggingface.co/PostHog/jeeves/tree/8622b7d1652a9dcb8629486b84dce9e8d690c5cd).
+- Jeeves code: [`f04ec5567301450dcaae0210dd54deeb4f647f87`](https://github.com/PostHog/jeeves/tree/f04ec5567301450dcaae0210dd54deeb4f647f87).
+- MLX-LM code: [`94cdcae13b266c337bcaca09b97b9c5a9c0e2cde`](https://github.com/ml-explore/mlx-lm/tree/94cdcae13b266c337bcaca09b97b9c5a9c0e2cde).
+- Conversion MLX requirement: `mlx[cpu]==0.32.3`; original build identity: `c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa`.
+
+[PACKAGE_MANIFEST.json](PACKAGE_MANIFEST.json) hashes the published payload except itself. [provenance/source_PACKAGE_MANIFEST.json](provenance/source_PACKAGE_MANIFEST.json) is the unmodified original manifest; its paths describe the original pre-publication package, not the newly documented payload. [RELEASE.json](RELEASE.json) distinguishes conversion evidence from packaging checks. Original `validation.json` is unchanged.
+
+## License and attribution
+
+Model weights follow the original **Apache-2.0** license retained in [LICENSE](LICENSE). Upstream Jeeves code is **MIT** licensed; its notice is retained in [LICENSE_JEEVES_CODE](LICENSE_JEEVES_CODE). Respect any additional notices in the included files. Credits for the original model, training, calibration, and serving research belong to PostHog and the upstream authors; this repository provides an unofficial MLX conversion/packaging.

RELEASE.json

@@ -0,0 +1,15 @@
+{
+  "branch": "main",
+  "conversion_identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "inference_run_by_publisher": false,
+  "publisher_version": "1.0.0",
+  "repo_id": "cowWhySo/jeeves-mlx",
+  "schema": "cowwhyso-jeeves-mlx-publisher/v1",
+  "scope": "Package integrity and publication only; not model-quality validation",
+  "source_package_bytes": 5075258092,
+  "source_repo": "PostHog/jeeves",
+  "source_revision": "8622b7d1652a9dcb8629486b84dce9e8d690c5cd",
+  "source_validation_status": "converted_and_small_cpu_diagnostics_passed_not_benchmarked",
+  "variant": "4bit",
+  "weights_modified_by_publisher": false
+}

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,79 @@
+{
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "bos_token_id": null,
+    "dtype": "bfloat16",
+    "eos_token_id": 248044,
+    "full_attention_interval": 4,
+    "head_dim": 256,
+    "hidden_act": "silu",
+    "hidden_size": 4096,
+    "initializer_range": 0.02,
+    "intermediate_size": 12288,
+    "layer_types": [
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention",
+        "linear_attention",
+        "linear_attention",
+        "linear_attention",
+        "full_attention"
+    ],
+    "linear_conv_kernel_dim": 4,
+    "linear_key_head_dim": 128,
+    "linear_num_key_heads": 16,
+    "linear_num_value_heads": 32,
+    "linear_value_head_dim": 128,
+    "max_position_embeddings": 262144,
+    "model_type": "qwen3_5",
+    "num_attention_heads": 16,
+    "num_hidden_layers": 32,
+    "num_key_value_heads": 4,
+    "pad_token_id": null,
+    "partial_rotary_factor": 0.25,
+    "quantization": {
+        "group_size": 64,
+        "bits": 4,
+        "mode": "affine"
+    },
+    "quantization_config": {
+        "group_size": 64,
+        "bits": 4,
+        "mode": "affine"
+    },
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+        "type": "default",
+        "rope_theta": 10000000,
+        "partial_rotary_factor": 0.25
+    },
+    "rope_theta": 10000000,
+    "tie_word_embeddings": false,
+    "torch_dtype": "bfloat16",
+    "vocab_size": 248320
+}

dataformat.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from dataclasses import dataclass, field
+from typing import Any, Iterable, Sequence
+
+CHOICE, NOUL, SCORE = "choice", "noul", "score"
+QUESTION_TYPES = (CHOICE, NOUL, SCORE)
+
+
+def render(value: Any, indent: int = 0) -> str:
+    pad = "  " * indent
+    if value is None:
+        return ""
+    if isinstance(value, (str, int, float, bool)):
+        return str(value)
+    if isinstance(value, list):
+        return "\n".join(f"{pad}- {render(x, indent + 1).lstrip()}" for x in value)
+    return "\n".join(
+        f"{pad}{k}:\n{render(v, indent + 1)}" if isinstance(v, (dict, list)) else f"{pad}{k}: {render(v)}"
+        for k, v in value.items()
+    )
+
+
+def option_text(name: str, desc: Any) -> str:
+    return name if desc is None or desc == "" else f"{name}: {render(desc)}"
+
+
+def state_hash(state: Any) -> str:
+    text = state if isinstance(state, str) else json.dumps(state, sort_keys=True, ensure_ascii=False)
+    return hashlib.sha256(" ".join(text.casefold().split()).encode()).hexdigest()
+
+
+@dataclass
+class Question:
+    id: str
+    type: str
+    instructions: Any
+    criteria: Any = None
+    label: Any = None
+    src: str = ""
+    target: dict[str, float] | None = None
+
+    def __post_init__(self) -> None:
+        if self.type not in QUESTION_TYPES:
+            raise ValueError(f"unknown question type {self.type!r}")
+        if self.type == CHOICE and not isinstance(self.criteria, dict):
+            raise ValueError(f"{self.id}: choice criteria must be a dict")
+        if self.type == SCORE and not isinstance(self.criteria, list):
+            raise ValueError(f"{self.id}: score criteria must be a list")
+        if self.type == NOUL and self.criteria is not None and not isinstance(self.criteria, dict):
+            raise ValueError(f"{self.id}: noul criteria must be a dict or null")
+
+    def keys(self) -> list[str]:
+        if self.type == CHOICE:
+            return list(self.criteria)
+        if self.type == NOUL:
+            return ["false", "true"]
+        return [str(i) for i in range(len(self.criteria))]
+
+    def instruction_text(self) -> str:
+        return render(self.instructions)
+
+    def options(self) -> list[str]:
+        if self.type == CHOICE:
+            return [option_text(k, v) for k, v in self.criteria.items()]
+        if self.type == NOUL:
+            c = self.criteria or {}
+            return [option_text("no", c.get("false")), option_text("yes", c.get("true"))]
+        return [render(x) for x in self.criteria]
+
+    def label_index(self) -> int:
+        if self.type == CHOICE:
+            return self.keys().index(self.label)
+        return int(self.label)
+
+    def target_vector(self) -> list[float] | None:
+        if self.target is None:
+            return None
+        t = [float(self.target.get(k, 0.0)) for k in self.keys()]
+        s = sum(t)
+        if s <= 0:
+            raise ValueError(f"{self.id}: target puts no mass on any option")
+        return [x / s for x in t]
+
+    def to_dict(self) -> dict[str, Any]:
+        d: dict[str, Any] = {"type": self.type, "instructions": self.instructions}
+        if self.criteria is not None or self.type != NOUL:
+            d["criteria"] = self.criteria
+        d["label"] = self.label
+        d["src"] = self.src
+        if self.target is not None:
+            d["target"] = self.target
+        return d
+
+    @classmethod
+    def from_dict(cls, qid: str, d: dict[str, Any]) -> "Question":
+        return cls(id=qid, type=d["type"], instructions=d["instructions"], criteria=d.get("criteria"),
+                   label=d.get("label"), src=d.get("src", ""), target=d.get("target"))
+
+
+@dataclass
+class DataFormat:
+    state: Any
+    questions: list[Question]
+    meta: dict[str, Any] = field(default_factory=dict)
+
+    def state_text(self) -> str:
+        return render(self.state)
+
+    def question(self, qid: str) -> Question:
+        for q in self.questions:
+            if q.id == qid:
+                return q
+        raise KeyError(qid)
+
+    @property
+    def source(self) -> str:
+        return self.meta.get("source", "")
+
+    @property
+    def id(self) -> str:
+        return self.meta.get("id", "")
+
+    def text_sha256(self) -> str:
+        return self.meta.get("text_sha256") or state_hash(self.state)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"state": self.state, "questions": {q.id: q.to_dict() for q in self.questions}, "_meta": self.meta}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> "DataFormat":
+        if "state" not in d or not isinstance(d.get("questions"), dict) or not d["questions"]:
+            raise ValueError("a record needs a state and a non-empty questions object")
+        return cls(state=d["state"], questions=[Question.from_dict(k, v) for k, v in d["questions"].items()],
+                   meta=dict(d.get("_meta", {})))
+
+    @classmethod
+    def from_json(cls, line: str) -> "DataFormat":
+        return cls.from_dict(json.loads(line))
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), ensure_ascii=False, default=str)
+
+
+def read_jsonl(path: str | os.PathLike) -> list[DataFormat]:
+    out = []
+    with open(path, encoding="utf-8") as fh:
+        for n, line in enumerate(fh, start=1):
+            if line.strip():
+                try:
+                    out.append(DataFormat.from_json(line))
+                except (ValueError, KeyError) as e:
+                    raise ValueError(f"{os.fspath(path)}:{n}: {e}") from e
+    return out
+
+
+def write_jsonl(path: str | os.PathLike, records: Iterable[DataFormat | dict]) -> int:
+    n = 0
+    with open(path, "w", encoding="utf-8", newline="\n") as fh:
+        for r in records:
+            fh.write((r.to_json() if isinstance(r, DataFormat) else json.dumps(r, ensure_ascii=False, default=str)) + "\n")
+            n += 1
+    return n
+
+
+def by_source(records: Sequence[DataFormat]) -> dict[str, list[DataFormat]]:
+    out: dict[str, list[DataFormat]] = {}
+    for r in records:
+        out.setdefault(r.source, []).append(r)
+    return out

example_request.json

@@ -0,0 +1,9 @@
+{
+  "state": "The customer was charged twice for one order.",
+  "questions": {
+    "billing": {
+      "type": "noul",
+      "instructions": "Is this a billing issue?"
+    }
+  }
+}

export.json

@@ -0,0 +1,111 @@
+{
+  "source_checkpoint": "runs/best_step402",
+  "base_model": "Qwen/Qwen3.5-9B",
+  "dtype": "bfloat16",
+  "format": "markers-v3-plainchains",
+  "head_dim": 256,
+  "temperature": 1.8589280843734741,
+  "stage": "cispo",
+  "step": 402,
+  "sources": {
+    "banking77": 0,
+    "boolq": 1,
+    "agnews": 2,
+    "mnli": 3,
+    "sst5": 4,
+    "yelp": 5,
+    "trec": 6,
+    "dbpedia14": 7,
+    "amazon": 8,
+    "imdb": 9,
+    "mmlu": 10,
+    "emotion": 11,
+    "tweet_offensive": 12,
+    "qnli": 13,
+    "paws": 14,
+    "sciq": 15,
+    "contrastive": 16,
+    "compositional": 17,
+    "composition_holdout": 18,
+    "semif": 19,
+    "wanli": 20,
+    "mmlu_pro": 21,
+    "buried": 22,
+    "unknowable": 23,
+    "unknowable_control": 24,
+    "night2_assertion": 25,
+    "night2_dates": 26,
+    "night2_unknowable": 27,
+    "night2_unknowable_control": 28
+  },
+  "metrics": null,
+  "training_config": {
+    "stage": "cispo",
+    "run_dir": "runs/cispo_rep",
+    "data_dir": "data",
+    "model": "Qwen/Qwen3.5-9B",
+    "init": "runs/sft_v4/final",
+    "resume": null,
+    "lora_r": 16,
+    "lora_alpha": 32.0,
+    "lora_dropout": 0.0,
+    "head_dim": 256,
+    "lr": 5e-05,
+    "head_lr": 0.0001,
+    "weight_decay": 0.0,
+    "warmup": 20,
+    "epochs": 4,
+    "max_steps": 0,
+    "batch_size": 8,
+    "grad_clip": 1.0,
+    "max_len": 4096,
+    "max_seq_len": 8192,
+    "train_limit": 0,
+    "dev_limit": 0,
+    "eval_every": 50,
+    "eval_batch_size": 16,
+    "eval_think": true,
+    "eval_think_limit": 256,
+    "log_every": 10,
+    "seed": 0,
+    "gradient_checkpointing": true,
+    "prompts_per_step": 8,
+    "group": 8,
+    "nothink_per_group": 0,
+    "nothink_start_epoch": 1,
+    "max_think": 2560,
+    "temperature": 1.0,
+    "top_p": 1.0,
+    "eps_high": 0.2,
+    "updates": 1,
+    "train_mix_frac": 0.0,
+    "rollout_ce_weight": 0.5,
+    "anchor_ce_weight": 0.5,
+    "anchor_batch": 8,
+    "gen_batch_size": 64,
+    "logprob_chunk": 128,
+    "micro_groups": 2,
+    "length_hinge": 2048,
+    "length_hinge_end": 1024,
+    "length_ramp": 0,
+    "length_penalty_weight": 1.0,
+    "length_penalty_cap": 0.1,
+    "length_penalty_correct_only": true,
+    "length_hinge2": 0,
+    "length_hinge2_end": 1792,
+    "length_penalty2_weight": 0.0,
+    "closure_reward": 0.0,
+    "pad_multiple": 128,
+    "num_workers": 2,
+    "compile": true,
+    "graph_decode": true,
+    "async_rollouts": true,
+    "ckpt_minutes": 45.0,
+    "log_rollouts": 3,
+    "log_chain_chars": 1200,
+    "sft_think_frac": 0.5,
+    "chain_cache": "data/chains",
+    "filter_active": false,
+    "filter_min_spread": 0.02
+  }
+}

fixtures.json

@@ -0,0 +1,338 @@
+[
+  {
+    "id": "case0",
+    "request": {
+      "state": "The customer was charged twice for one order.",
+      "questions": {
+        "billing": {
+          "type": "noul",
+          "instructions": "Is this a billing issue?",
+          "label": 1
+        }
+      }
+    },
+    "ids": [
+      248045,
+      846,
+      198,
+      248060,
+      760,
+      5813,
+      557,
+      11102,
+      10598,
+      364,
+      799,
+      1906,
+      13,
+      198,
+      248061,
+      3742,
+      411,
+      264,
+      32419,
+      4125,
+      30,
+      198,
+      248049,
+      2083,
+      248050,
+      198,
+      248049,
+      9405,
+      248050,
+      248046,
+      198,
+      248045,
+      74455,
+      198,
+      248068,
+      198,
+      198,
+      248069,
+      271,
+      248049,
+      2083,
+      248050,
+      198,
+      248049,
+      9405,
+      248050,
+      198,
+      248062
+    ],
+    "option_positions": [
+      41,
+      45
+    ],
+    "decide_position": 47,
+    "keys": [
+      "false",
+      "true"
+    ],
+    "input_tokens": 48
+  },
+  {
+    "id": "case1",
+    "request": {
+      "state": {
+        "status": "delivered",
+        "refund_requested": false
+      },
+      "questions": {
+        "status": {
+          "type": "choice",
+          "instructions": "What is the order status?",
+          "criteria": {
+            "delivered": null,
+            "cancelled": null
+          },
+          "label": "delivered"
+        }
+      }
+    },
+    "ids": [
+      248045,
+      846,
+      198,
+      248060,
+      2738,
+      25,
+      12238,
+      198,
+      66165,
+      70238,
+      25,
+      3439,
+      198,
+      248061,
+      3710,
+      369,
+      279,
+      1906,
+      2552,
+      30,
+      198,
+      248049,
+      9302,
+      41636,
+      248050,
+      198,
+      248049,
+      91993,
+      248050,
+      248046,
+      198,
+      248045,
+      74455,
+      198,
+      248068,
+      198,
+      198,
+      248069,
+      271,
+      248049,
+      9302,
+      41636,
+      248050,
+      198,
+      248049,
+      91993,
+      248050,
+      198,
+      248062
+    ],
+    "option_positions": [
+      42,
+      46
+    ],
+    "decide_position": 48,
+    "keys": [
+      "delivered",
+      "cancelled"
+    ],
+    "input_tokens": 49
+  },
+  {
+    "id": "case2",
+    "request": {
+      "state": "The product was excellent.",
+      "questions": {
+        "sentiment": {
+          "type": "score",
+          "instructions": "Rate the sentiment.",
+          "criteria": [
+            "negative",
+            "neutral",
+            "positive"
+          ],
+          "label": 2
+        }
+      }
+    },
+    "ids": [
+      248045,
+      846,
+      198,
+      248060,
+      760,
+      1918,
+      557,
+      8800,
+      13,
+      198,
+      248061,
+      11231,
+      279,
+      25144,
+      13,
+      198,
+      248049,
+      40823,
+      248050,
+      198,
+      248049,
+      57555,
+      248050,
+      198,
+      248049,
+      29492,
+      248050,
+      248046,
+      198,
+      248045,
+      74455,
+      198,
+      248068,
+      198,
+      198,
+      248069,
+      271,
+      248049,
+      40823,
+      248050,
+      198,
+      248049,
+      57555,
+      248050,
+      198,
+      248049,
+      29492,
+      248050,
+      198,
+      248062
+    ],
+    "option_positions": [
+      39,
+      43,
+      47
+    ],
+    "decide_position": 49,
+    "keys": [
+      "0",
+      "1",
+      "2"
+    ],
+    "input_tokens": 50
+  },
+  {
+    "id": "case3",
+    "request": {
+      "state": "Quoted text: <|box_end|> <|fim_suffix|>.",
+      "questions": {
+        "quoted": {
+          "type": "choice",
+          "instructions": "Classify the quoted text.",
+          "criteria": {
+            "literal marker": "<|box_end|>",
+            "other": null
+          },
+          "label": "literal marker"
+        }
+      }
+    },
+    "ids": [
+      248045,
+      846,
+      198,
+      248060,
+      2114,
+      8979,
+      1414,
+      25,
+      361,
+      62438,
+      1944,
+      6018,
+      62438,
+      29,
+      361,
+      62438,
+      244288,
+      35920,
+      62438,
+      13867,
+      198,
+      248061,
+      1890,
+      1386,
+      279,
+      22513,
+      1414,
+      13,
+      198,
+      248049,
+      34600,
+      10811,
+      25,
+      361,
+      62438,
+      1944,
+      6018,
+      62438,
+      29,
+      248050,
+      198,
+      248049,
+      1520,
+      248050,
+      248046,
+      198,
+      248045,
+      74455,
+      198,
+      248068,
+      198,
+      198,
+      248069,
+      271,
+      248049,
+      34600,
+      10811,
+      25,
+      361,
+      62438,
+      1944,
+      6018,
+      62438,
+      29,
+      248050,
+      198,
+      248049,
+      1520,
+      248050,
+      198,
+      248062
+    ],
+    "option_positions": [
+      64,
+      68
+    ],
+    "decide_position": 70,
+    "keys": [
+      "literal marker",
+      "other"
+    ],
+    "input_tokens": 71
+  }
+]

head.pt

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

head.safetensors

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

jeeves_format.py

@@ -0,0 +1,92 @@
+# Extracted from PostHog/jeeves loader/dataloader.py (MIT).
+# Only training imports/unused nodes were removed; see LICENSE_JEEVES_CODE.
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+from transformers import AutoTokenizer
+from dataformat import DataFormat, Question
+STATE, Q, OPT, OPT_END, DECIDE = ('<|fim_prefix|>', '<|fim_middle|>', '<|box_start|>', '<|box_end|>', '<|fim_suffix|>')
+THINK, THINK_END = ('<think>', '</think>')
+CONTROL_RE = re.compile('<\\|([A-Za-z0-9_]+)\\|>')
+
+def sanitize(text: str) -> str:
+    return CONTROL_RE.sub('<¦\\1¦>', text)
+
+@dataclass
+class Example:
+    prompt: list[int]
+    remainder: list[int]
+    label: int
+    target: list[float] | None
+    n_options: int
+    source: str
+    source_id: int
+    record_id: str
+    question_id: str
+    think: list[int] | None = None
+    plain_prompt: list[int] | None = None
+
+    @property
+    def full(self) -> list[int]:
+        return self.prompt + self.remainder
+
+@dataclass(frozen=True)
+class Markers:
+    pad_id: int
+    opt_end_id: int
+    think_end_id: int
+    empty_think: tuple[int, ...]
+    pad_multiple: int
+
+class Encoder:
+    FORMAT = 'markers-v3-plainchains'
+
+    def __init__(self, tokenizer_repo: str='Qwen/Qwen3.5-9B', pad_multiple: int=128):
+        self.tok = AutoTokenizer.from_pretrained(tokenizer_repo)
+        self.pad_multiple = pad_multiple
+        ids = self.tok.convert_tokens_to_ids([STATE, Q, OPT, OPT_END, DECIDE, THINK, THINK_END])
+        if any((i is None or i == self.tok.unk_token_id for i in ids)):
+            raise ValueError('marker tokens missing from tokenizer')
+        self.state_id, self.q_id, self.opt_id, self.opt_end_id, self.decide_id, self.think_id, self.think_end_id = ids
+        self.pad_id = self.tok.pad_token_id
+        special = set(self.tok.all_special_ids) | set(self.tok.get_added_vocab().values())
+        self.banned_ids = sorted(special - {self.think_end_id})
+        self.empty_think = self.encode('\n')
+
+    @property
+    def markers(self) -> Markers:
+        return Markers(self.pad_id, self.opt_end_id, self.think_end_id, tuple(self.empty_think), self.pad_multiple)
+
+    def encode(self, text: str) -> list[int]:
+        return self.tok(text, add_special_tokens=False).input_ids
+
+    @staticmethod
+    def option_block(q: Question) -> str:
+        return ''.join((f'{OPT}{sanitize(o)}{OPT_END}\n' for o in q.options()))
+
+    def chat(self, content: str) -> str:
+        return self.tok.apply_chat_template([{'role': 'user', 'content': content}], tokenize=False, add_generation_prompt=True, enable_thinking=True)
+
+    def prompt_text(self, record: DataFormat, q: Question) -> str:
+        return self.chat(f'{STATE}{sanitize(record.state_text())}\n{Q}{sanitize(q.instruction_text())}\n{self.option_block(q)}')
+
+    def plain_prompt_text(self, record: DataFormat, q: Question) -> str:
+        options = '\n'.join((sanitize(o) for o in q.options()))
+        return self.chat(f'Context:\n{sanitize(record.state_text())}\n\nQuestion: {sanitize(q.instruction_text())}\n\nOptions:\n{options}')
+
+    def remainder_text(self, q: Question) -> str:
+        return f'{THINK_END}\n\n{self.option_block(q)}{DECIDE}'
+
+    def example(self, record: DataFormat, q: Question, source_id: int) -> Example:
+        prompt = self.encode(self.prompt_text(record, q))
+        remainder = self.encode(self.remainder_text(q))
+        if prompt[-2:] != self.encode(f'{THINK}\n') or remainder[0] != self.think_end_id or remainder[-1] != self.decide_id:
+            raise ValueError(f'unexpected layout for {record.id}/{q.id}')
+        if remainder.count(self.opt_end_id) != len(q.options()):
+            raise ValueError(f'option boundary count mismatch for {record.id}/{q.id}')
+        return Example(prompt=prompt, remainder=remainder, label=q.label_index(), target=q.target_vector(), n_options=len(q.options()), source=record.source, source_id=source_id, record_id=record.id, question_id=q.id, plain_prompt=self.encode(self.plain_prompt_text(record, q)))
+
+def readout_positions(ids: list[int], m: Markers) -> tuple[list[int], int]:
+    start = len(ids) - 1 - ids[::-1].index(m.think_end_id)
+    opts = [i for i in range(start, len(ids)) if ids[i] == m.opt_end_id]
+    return (opts, len(ids) - 1)

jeeves_support.py

@@ -0,0 +1,177 @@
+"""Standard-library helpers for the Jeeves CPU conversion notebook."""
+from __future__ import annotations
+import ast
+import hashlib
+import json
+import math
+import os
+import struct
+from pathlib import Path
+
+FORMAT_VERSION = "jeeves-mlx-cpu-v1"
+
+
+def write_json(path, value):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_name(path.name + ".tmp")
+    temp.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n", encoding="utf-8")
+    os.replace(temp, path)
+
+
+def read_json(path):
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+def sha256(path, block_size=8 * 1024 * 1024):
+    h = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for chunk in iter(lambda: stream.read(block_size), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def fingerprint(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def adapt_config(original):
+    """Adapt metadata only. Leave all tensor transforms to MLX-LM."""
+    cfg = json.loads(json.dumps(original))
+    if "text_config" in cfg:
+        raise ValueError("This notebook targets the flat Jeeves export, not a new nested export.")
+    required = ("layer_types", "num_hidden_layers", "rope_theta", "partial_rotary_factor", "hidden_size")
+    for key in required:
+        if key not in cfg:
+            raise ValueError(f"Missing source configuration field: {key}")
+    expected = ["full_attention" if (i + 1) % 4 == 0 else "linear_attention"
+                for i in range(cfg["num_hidden_layers"])]
+    if cfg["layer_types"] != expected:
+        raise ValueError("Layer schedule changed. Do not guess full_attention_interval.")
+    if cfg.get("hidden_act", "silu") != "silu" or cfg.get("num_experts", 0):
+        raise ValueError("Unsupported architecture change in this source revision.")
+    if cfg.get("quantization") or cfg.get("quantization_config"):
+        raise ValueError("Expected unquantized, fused Jeeves weights.")
+    cfg["model_type"] = "qwen3_5"
+    cfg["full_attention_interval"] = 4
+    cfg["rope_parameters"] = {
+        "type": "default", "rope_theta": cfg["rope_theta"],
+        "partial_rotary_factor": cfg["partial_rotary_factor"],
+    }
+    cfg["torch_dtype"] = cfg.get("dtype", "bfloat16")
+    return cfg
+
+
+def safetensors_header(path):
+    """Validate container length/offsets without loading multi-GB tensors."""
+    path = Path(path)
+    size = path.stat().st_size
+    with path.open("rb") as stream:
+        raw = stream.read(8)
+        if len(raw) != 8:
+            raise ValueError(f"Truncated Safetensors file: {path}")
+        length = struct.unpack("<Q", raw)[0]
+        if length < 2 or length > min(64 * 1024 * 1024, size - 8):
+            raise ValueError(f"Invalid Safetensors header length: {path}")
+        header = json.loads(stream.read(length))
+    data_bytes = size - 8 - length
+    tensors = {k: v for k, v in header.items() if k != "__metadata__"}
+    widths = {"BOOL": 1, "U8": 1, "I8": 1, "F8_E4M3": 1, "F8_E5M2": 1,
+              "I16": 2, "U16": 2, "F16": 2, "BF16": 2, "I32": 4, "U32": 4,
+              "F32": 4, "F64": 8, "I64": 8, "U64": 8}
+    spans = []
+    for name, t in tensors.items():
+        start, end = t["data_offsets"]
+        shape = t["shape"]
+        if any(not isinstance(x, int) or x < 0 for x in shape):
+            raise ValueError(f"Invalid tensor shape: {name}")
+        if not (0 <= start <= end <= data_bytes):
+            raise ValueError(f"Invalid tensor offsets: {path.name}:{name}")
+        if t["dtype"] in widths and end - start != math.prod(shape) * widths[t["dtype"]]:
+            raise ValueError(f"Tensor byte count mismatch: {name}")
+        spans.append((start, end))
+    cursor = 0
+    for start, end in sorted(spans):
+        if start != cursor:
+            raise ValueError(f"Tensor gaps/overlaps in {path}")
+        cursor = end
+    if cursor != data_bytes:
+        raise ValueError(f"Unexpected trailing data in {path}")
+    return tensors
+
+
+def inspect_model(directory):
+    directory = Path(directory)
+    index = read_json(directory / "model.safetensors.index.json")
+    mapping = index["weight_map"]
+    found, nbytes = {}, 0
+    for filename in sorted(set(mapping.values())):
+        if Path(filename).name != filename:
+            raise ValueError("Unexpected nested shard path")
+        path = directory / filename
+        header = safetensors_header(path)
+        for key, info in header.items():
+            if key in found or mapping.get(key) != filename:
+                raise ValueError(f"Duplicate or incorrectly indexed tensor: {key}")
+            found[key] = info
+            nbytes += info["data_offsets"][1] - info["data_offsets"][0]
+    if set(mapping) != set(found):
+        raise ValueError("Shard/index tensor inventory mismatch")
+    advertised = index.get("metadata", {}).get("total_size")
+    if advertised is not None and advertised != nbytes:
+        raise ValueError(f"Tensor byte total mismatch: {advertised} != {nbytes}")
+    return {"tensor_count": len(found), "tensor_bytes": nbytes, "tensors": found}
+
+
+def extract_encoder(source_text):
+    """Retain upstream encoder AST nodes; remove only training/PyTorch imports."""
+    parsed = ast.parse(source_text)
+    wanted = {"sanitize", "Example", "Markers", "Encoder", "readout_positions"}
+    assignments = {"STATE", "Q", "OPT", "OPT_END", "DECIDE", "THINK", "THINK_END", "CONTROL_RE"}
+    nodes, seen = [], set()
+    for node in parsed.body:
+        if isinstance(node, (ast.ClassDef, ast.FunctionDef)) and node.name in wanted:
+            nodes.append(node)
+            seen.add(node.name)
+        elif isinstance(node, ast.Assign):
+            names = {n.id for target in node.targets for n in ast.walk(target) if isinstance(n, ast.Name)}
+            if names and names <= assignments:
+                nodes.append(node)
+                seen.update(names)
+    if seen != wanted | assignments:
+        raise ValueError(f"Upstream encoder structure changed: missing {(wanted | assignments) - seen}")
+    imports = ast.parse("from __future__ import annotations\nimport re\nfrom dataclasses import dataclass\n"
+                        "from transformers import AutoTokenizer\nfrom dataformat import DataFormat, Question\n").body
+    module = ast.Module(body=imports + nodes, type_ignores=[])
+    ast.fix_missing_locations(module)
+    text = ("# Extracted from PostHog/jeeves loader/dataloader.py (MIT).\n"
+            "# Only training imports/unused nodes were removed; see LICENSE_JEEVES_CODE.\n" + ast.unparse(module) + "\n")
+    compile(text, "jeeves_format.py", "exec")
+    return text
+
+
+def build_manifest(directory, identity):
+    directory = Path(directory)
+    files = {}
+    for path in sorted(directory.rglob("*")):
+        if not path.is_file() or path.name == "PACKAGE_MANIFEST.json" or "__pycache__" in path.parts:
+            continue
+        name = path.relative_to(directory).as_posix()
+        files[name] = {"bytes": path.stat().st_size, "sha256": sha256(path)}
+    value = {"schema": FORMAT_VERSION, "identity": identity, "files": files}
+    write_json(directory / "PACKAGE_MANIFEST.json", value)
+    return value
+
+
+def verify_manifest(directory, identity=None):
+    directory = Path(directory)
+    manifest = read_json(directory / "PACKAGE_MANIFEST.json")
+    if identity is not None and manifest["identity"] != identity:
+        raise ValueError("Package belongs to a different conversion identity.")
+    for name, item in manifest["files"].items():
+        path = directory / name
+        if not path.is_relative_to(directory) or ".." in Path(name).parts:
+            raise ValueError("Unsafe manifest path")
+        if not path.is_file() or path.stat().st_size != item["bytes"] or sha256(path) != item["sha256"]:
+            raise ValueError(f"Package integrity check failed: {name}")
+    return manifest

model.safetensors

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

model.safetensors.index.json

@@ -0,0 +1,935 @@
+{
+    "metadata": {
+        "total_size": 5038040064,
+        "total_parameters": 8953801728
+    },
+    "weight_map": {
+        "language_model.lm_head.biases": "model.safetensors",
+        "language_model.lm_head.scales": "model.safetensors",
+        "language_model.lm_head.weight": "model.safetensors",
+        "language_model.model.embed_tokens.biases": "model.safetensors",
+        "language_model.model.embed_tokens.scales": "model.safetensors",
+        "language_model.model.embed_tokens.weight": "model.safetensors",
+        "language_model.model.layers.0.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.0.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.0.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.0.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.0.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.0.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.1.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.1.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.1.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.1.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.1.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.1.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.10.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.10.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.10.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.10.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.10.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.10.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.11.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.11.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.11.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.11.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.12.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.12.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.12.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.12.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.12.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.12.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.12.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.12.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.12.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.12.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.12.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.12.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.13.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.13.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.13.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.13.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.13.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.13.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.13.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.13.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.13.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.13.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.13.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.13.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.14.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.14.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.14.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.14.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.14.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.14.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.14.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.14.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.14.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.14.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.14.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.14.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.15.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.15.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.15.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.15.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.15.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.15.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.15.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.15.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.15.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.15.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.15.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.15.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.15.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.16.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.16.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.16.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.16.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.16.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.16.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.16.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.16.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.16.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.16.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.16.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.16.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.17.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.17.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.17.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.17.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.17.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.17.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.17.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.17.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.17.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.17.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.17.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.17.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.18.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.18.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.18.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.18.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.18.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.18.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.18.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.18.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.18.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.18.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.18.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.18.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.19.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.19.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.19.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.19.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.19.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.19.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.19.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.19.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.19.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.19.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.19.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.19.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.19.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.2.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.2.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.2.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.2.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.2.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.20.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.20.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.20.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.20.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.20.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.20.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.20.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.20.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.20.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.20.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.20.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.20.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.21.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.21.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.21.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.21.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.21.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.21.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.21.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.21.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.21.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.21.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.21.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.21.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.22.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.22.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.22.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.22.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.22.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.22.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.22.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.22.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.22.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.22.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.22.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.22.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.23.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.23.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.23.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.23.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.23.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.23.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.23.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.23.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.23.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.23.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.23.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.23.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.23.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.24.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.24.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.24.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.24.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.24.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.24.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.24.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.24.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.24.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.24.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.24.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.24.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.25.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.25.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.25.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.25.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.25.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.25.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.25.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.25.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.25.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.25.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.25.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.25.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.26.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.26.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.26.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.26.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.26.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.26.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.26.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.26.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.26.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.26.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.26.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.26.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.27.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.27.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.27.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.27.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.27.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.27.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.27.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.27.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.27.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.27.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.27.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.27.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.27.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.28.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.28.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.28.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.28.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.28.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.28.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.28.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.28.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.28.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.28.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.28.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.28.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.29.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.29.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.29.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.29.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.29.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.29.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.29.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.29.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.29.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.29.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.29.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.29.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.3.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.3.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.3.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.3.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.30.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.30.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.30.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.30.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.30.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.30.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.30.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.30.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.30.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.30.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.30.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.30.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.31.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.31.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.31.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.31.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.31.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.31.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.31.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.31.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.31.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.31.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.31.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.31.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.31.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.4.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.4.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.4.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.4.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.4.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.5.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.5.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.5.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.5.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.5.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.5.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.6.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.6.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.6.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.6.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.6.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.6.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.7.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.k_norm.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.k_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.self_attn.k_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.k_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.o_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.self_attn.o_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.o_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.q_norm.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.q_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.self_attn.q_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.q_proj.weight": "model.safetensors",
+        "language_model.model.layers.7.self_attn.v_proj.biases": "model.safetensors",
+        "language_model.model.layers.7.self_attn.v_proj.scales": "model.safetensors",
+        "language_model.model.layers.7.self_attn.v_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.8.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.8.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.8.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.8.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.8.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.9.input_layernorm.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.A_log": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.conv1d.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.dt_bias": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_a.biases": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_a.scales": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_a.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_b.biases": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_b.scales": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_b.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_qkv.biases": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_qkv.scales": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_qkv.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_z.biases": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_z.scales": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.in_proj_z.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.norm.weight": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.out_proj.biases": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.out_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.linear_attn.out_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.down_proj.biases": "model.safetensors",
+        "language_model.model.layers.9.mlp.down_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.down_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.gate_proj.biases": "model.safetensors",
+        "language_model.model.layers.9.mlp.gate_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.gate_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.mlp.up_proj.biases": "model.safetensors",
+        "language_model.model.layers.9.mlp.up_proj.scales": "model.safetensors",
+        "language_model.model.layers.9.mlp.up_proj.weight": "model.safetensors",
+        "language_model.model.layers.9.post_attention_layernorm.weight": "model.safetensors",
+        "language_model.model.norm.weight": "model.safetensors"
+    }
+}

provenance/bf16_weight_audit.json

@@ -0,0 +1,5 @@
+{
+  "status": "passed",
+  "tensors_shape_checked": 427,
+  "scope": "All tensor names/shapes; full norm and convolution tensors; first 2 rows x 64 columns of other tensors. Not all-element equality."
+}

provenance/conversion_run_lock.json

@@ -0,0 +1,32 @@
+{
+  "request": {
+    "schema": "jeeves-mlx-cpu-v1",
+    "repo_id": "PostHog/jeeves",
+    "hf_revision": "8622b7d1652a9dcb8629486b84dce9e8d690c5cd",
+    "jeeves_code_ref": "HEAD",
+    "mlx_lm_code_ref": "refs/heads/main",
+    "mlx_requirement": "mlx[cpu]==0.32.3",
+    "quant_bits": [
+      4,
+      8
+    ],
+    "q_group_size": 64,
+    "run_torch_reference": true,
+    "run_cpu_smoke": true,
+    "smoke_cases": 1,
+    "smoke_max_tokens": 256,
+    "prefill_chunk_size": 16,
+    "greedy_smoke_tokens": 0,
+    "min_ram_gib": 24,
+    "bf16_probability_atol": 0.02,
+    "bf16_min_cosine": 0.995,
+    "helper_sha256": {
+      "jeeves_support.py": "26ca899ee62b13ef3a93ff7075bf4fcfd097e1c1e15589b667c22be71205beb6",
+      "run_jeeves.py": "5e381f42611ee195f4579eb3d3433abf7c292aecb26e52b6ccd94ecd4e13c654",
+      "convert_worker.py": "538444544ae39fdbe5031b0a75dcff88615b33e1127d7eb42fefde325c36afd7"
+    }
+  },
+  "jeeves_code_sha": "f04ec5567301450dcaae0210dd54deeb4f647f87",
+  "mlx_lm_sha": "94cdcae13b266c337bcaca09b97b9c5a9c0e2cde",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa"
+}

provenance/format_head_checks.json

@@ -0,0 +1,14 @@
+{
+  "status": "passed",
+  "format_cases": 4,
+  "original_head_dtypes": {
+    "q.weight": "torch.float32",
+    "q.bias": "torch.float32",
+    "k.weight": "torch.float32",
+    "k.bias": "torch.float32"
+  },
+  "exported_head_dtype": "float32",
+  "temperature": 1.8589280843734741,
+  "max_head_probability_error": 0.0,
+  "scope": "Original encoder token/readout parity, safe head serialization, and original PyTorch head vs MLX head on synthetic hidden states. Not backbone parity."
+}

provenance/jeeves-mlx-4bit.npz

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

provenance/jeeves-mlx-4bit_smoke.json

@@ -0,0 +1,17 @@
+{
+  "status": "passed",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "device": "cpu",
+  "cases": [
+    {
+      "id": "case0",
+      "probabilities": [
+        0.016998127102851868,
+        0.9830018877983093
+      ],
+      "elapsed_seconds": 4345.674271831
+    }
+  ],
+  "fixture_sha256": "2887c941fd5a497ae51343a9e2382ea1d198ab5eb140f4e8c8fd37c54be4ebf0",
+  "scope": "Small no-thinking execution smoke test; not a benchmark."
+}

provenance/jeeves-mlx-bf16.npz

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

provenance/jeeves-mlx-bf16_smoke.json

@@ -0,0 +1,17 @@
+{
+  "status": "passed",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "device": "cpu",
+  "cases": [
+    {
+      "id": "case0",
+      "probabilities": [
+        0.03329608216881752,
+        0.9667038917541504
+      ],
+      "elapsed_seconds": 268.5726169540003
+    }
+  ],
+  "fixture_sha256": "2887c941fd5a497ae51343a9e2382ea1d198ab5eb140f4e8c8fd37c54be4ebf0",
+  "scope": "Small no-thinking execution smoke test; not a benchmark."
+}

provenance/original_package_README.md

@@ -0,0 +1,33 @@
+# Jeeves-9B MLX — jeeves-mlx-4bit
+
+Converted from `PostHog/jeeves` revision `8622b7d1652a9dcb8629486b84dce9e8d690c5cd` on CPU.
+This is an unofficial MLX port, not a release by PostHog or Apple.
+
+## Contents
+
+`model*.safetensors` and `config.json` are the MLX backbone. `head.safetensors` contains the original pointer-head values in FP32. `head.pt` is also retained. `export.json` retains the released temperature and training metadata. `jeeves_format.py` is extracted from the pinned upstream encoder; `dataformat.py` retains the original state/question rendering. Original licenses and source hashes are preserved.
+
+## Apple Silicon
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -r requirements-mac.txt
+python run_jeeves.py --request example_request.json --device gpu
+```
+
+Ordinary, non-speculative greedy reasoning is optional:
+
+```bash
+python run_jeeves.py --request example_request.json --device gpu --think-tokens 128
+```
+
+The runner accepts `state` and a `questions` mapping with `noul`, `choice`, or `score` question types. It returns one probability per option. It is **not** a wire-compatible replacement for the original `/v1/systemone` server. Use `run_jeeves.py`, not `mlx_lm.generate`, for decisions.
+
+## Scope and validation
+
+The default path is no-thinking, batch size one, with an independent cache per question. The optional reasoning path uses ordinary greedy decoding, suppresses the upstream control tokens, stops at the thinking end marker, and re-prefills for decision readout. It does not reproduce the original speculative drafters, CUDA graphs, FP8 serving, or adaptive no-thinking threshold.
+
+Read `validation.json` for this package's actual status. A file conversion, head check, or tiny smoke-test pass is not an accuracy/calibration benchmark. An unchanged temperature does not establish calibration after quantization. Apple Metal execution and latency must be tested on a Mac. No advertised Jeeves benchmark score or speed is claimed for this port.
+
+The source checkpoint license is in `LICENSE`; the upstream code license is in `LICENSE_JEEVES_CODE`. The new glue code is supplied for use and modification without warranty.

provenance/preflight.json

@@ -0,0 +1,14 @@
+{
+  "status": "passed",
+  "device": "cpu",
+  "versions": {
+    "mlx": "0.32.3",
+    "mlx-lm": "0.31.4.dev132+g94cdcae13",
+    "torch": "2.14.0+cpu",
+    "numpy": "2.5.3",
+    "transformers": "5.17.0",
+    "huggingface-hub": "1.33.0",
+    "safetensors": "0.8.0"
+  },
+  "scope": "Tiny synthetic architecture; not the Jeeves checkpoint."
+}

provenance/requirements-cpu-lock.txt

@@ -0,0 +1,41 @@
+annotated-doc==0.0.5
+anyio==4.15.1
+certifi==2026.7.22
+click==8.5.0
+filelock==3.32.3
+fsspec==2026.7.0
+h11==0.16.0
+hf-xet==1.6.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.33.0
+idna==3.20
+Jinja2==3.1.6
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+mlx==0.32.3
+mlx-cpu==0.32.3
+mlx-lm @ git+https://github.com/ml-explore/mlx-lm.git@94cdcae13b266c337bcaca09b97b9c5a9c0e2cde
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.5.3
+packaging==26.3
+protobuf==7.36.2
+psutil==7.2.2
+Pygments==2.21.0
+PyYAML==6.0.3
+regex==2026.9.29
+rich==15.0.0
+safetensors==0.8.0
+sentencepiece==0.2.2
+setuptools==84.0.0
+shellingham==1.5.4
+sympy==1.14.0
+tokenizers==0.23.2
+torch==2.14.0+cpu
+tqdm==4.70.1
+transformers==5.17.0
+typer==0.27.2
+typing_extensions==4.16.0
+wheel==0.48.0

provenance/source_PACKAGE_MANIFEST.json

@@ -0,0 +1,154 @@
+{
+  "schema": "jeeves-mlx-cpu-v1",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "files": {
+    "CONVERSION_COMPLETE.json": {
+      "bytes": 269,
+      "sha256": "cb7ff21cfa818a070dc01cb79829ceca9e293e5c9dfc400ab8c8a81a4699b383"
+    },
+    "LICENSE": {
+      "bytes": 11544,
+      "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a"
+    },
+    "LICENSE_JEEVES_CODE": {
+      "bytes": 1074,
+      "sha256": "823f556c20700f9a2f5e520c7d4eb3089f083fb19cf618cdbe08c08982f41b8e"
+    },
+    "README.md": {
+      "bytes": 2192,
+      "sha256": "fc5140a87a684cb672186d46c739e8482174854632dbcb929985ffda6eced3a9"
+    },
+    "chat_template.jinja": {
+      "bytes": 7756,
+      "sha256": "a4aee8afcf2e0711942cf848899be66016f8d14a889ff9ede07bca099c28f715"
+    },
+    "config.json": {
+      "bytes": 2080,
+      "sha256": "6cc3a4bc9bd804159d7849476564026451ace6009b7fc51cdf14908aaacf333a"
+    },
+    "dataformat.py": {
+      "bytes": 6058,
+      "sha256": "1c421b0e2ba879f5799842b3a44350d1f1db117ead23c47c7b01a27e2139c664"
+    },
+    "example_request.json": {
+      "bytes": 179,
+      "sha256": "7cec13b2283352be787736c7bb47fb783b61814f9ed25fb9ac2742d521435145"
+    },
+    "export.json": {
+      "bytes": 2582,
+      "sha256": "608d8aa594bc9cc6cd37e691eb3b5ec0e661866be0ae38f21659f6d70531e8a1"
+    },
+    "fixtures.json": {
+      "bytes": 4863,
+      "sha256": "2887c941fd5a497ae51343a9e2382ea1d198ab5eb140f4e8c8fd37c54be4ebf0"
+    },
+    "head.pt": {
+      "bytes": 8392767,
+      "sha256": "2ab935dea9eecf263086d9ed6dfe97fd5558193663ecae102fd3c50ae6878d60"
+    },
+    "head.safetensors": {
+      "bytes": 8391016,
+      "sha256": "ceac931470abafbc62723a297291f2c3d96627679794433585e658981798343e"
+    },
+    "jeeves_format.py": {
+      "bytes": 4244,
+      "sha256": "6bb9599483ce4328024bf2c8473959996b3c55a226ae2a31c739ec87b0f215ca"
+    },
+    "jeeves_support.py": {
+      "bytes": 7920,
+      "sha256": "26ca899ee62b13ef3a93ff7075bf4fcfd097e1c1e15589b667c22be71205beb6"
+    },
+    "model.safetensors": {
+      "bytes": 5038161163,
+      "sha256": "a7f3c503106f38d7bff3a55cb16b82bb5085fd8247893ade8a1de6ed1750e1f1"
+    },
+    "model.safetensors.index.json": {
+      "bytes": 81194,
+      "sha256": "215f9abadc1cea4d465b01c036dffcac5a84c2fb2386777863eff6928b91ed0b"
+    },
+    "provenance/bf16_weight_audit.json": {
+      "bytes": 201,
+      "sha256": "a4668cfbcf61c2946e870e552776d876f8cfd1cd021b4bda5f30795bfa545ee4"
+    },
+    "provenance/format_head_checks.json": {
+      "bytes": 481,
+      "sha256": "fb3c9913a7d9200186d9b4ec7e79701e1b9fb0e9513636e7b84db716584140ce"
+    },
+    "provenance/jeeves-mlx-4bit.npz": {
+      "bytes": 49972,
+      "sha256": "b23046076e0105c29e487312856067b9e4c0a4d53ced30a543b5543911551ba7"
+    },
+    "provenance/jeeves-mlx-4bit_smoke.json": {
+      "bytes": 467,
+      "sha256": "4f76a693cf949f7cdd3eac7b573b8e15083e5a3f0b7614a06ec449a525c05baf"
+    },
+    "provenance/jeeves-mlx-bf16.npz": {
+      "bytes": 49972,
+      "sha256": "20f08bc1b539c2b7321c666c73faba142141641db0c27757958a1f463e92f52c"
+    },
+    "provenance/jeeves-mlx-bf16_smoke.json": {
+      "bytes": 469,
+      "sha256": "09b6e75e09a1b51d571e0309e9de7f566b33a5aa86fa039a5669577717dade0d"
+    },
+    "provenance/preflight.json": {
+      "bytes": 337,
+      "sha256": "6cc3ab0b1b759f6751f68ca3867f9648573a69e9632840feb42cb2b60daf27c6"
+    },
+    "provenance/source_config.json": {
+      "bytes": 1471,
+      "sha256": "b0ca5d0cb2056e4c1a4eb9a0616c114773cbd8b7428c1927259b28b3938b4191"
+    },
+    "provenance/source_lock.json": {
+      "bytes": 302,
+      "sha256": "d96f01e2558461e3c3daa874755a8212af64591840f6e6c8415f73ad8328e446"
+    },
+    "provenance/source_shards.json": {
+      "bytes": 913,
+      "sha256": "8f7b5da3ef9b11a19ff1976b382fc5908989beab726c68ad8ef70b6db7c57f8e"
+    },
+    "provenance/torch_reference.json": {
+      "bytes": 504,
+      "sha256": "1ff8eed755e0c8d4febb490a8be902c4b21a33802e428ff23047a31109d41c8c"
+    },
+    "provenance/torch_reference.npz": {
+      "bytes": 49972,
+      "sha256": "852fadb6c779fbbb45073590aa5f08f6385f903dad22c8a6ab27d6613de5ebba"
+    },
+    "provenance/upstream_code.json": {
+      "bytes": 799,
+      "sha256": "d50143f13dac140feb845dfef53380e370371f6c95412bee6b212d5387bb7987"
+    },
+    "provenance/upstream_dataloader.py": {
+      "bytes": 11424,
+      "sha256": "7d8a43ddcac427125bbe6b8aca9cfb3306aa1dbef6d7509bfed1a65a2d93b4d1"
+    },
+    "provenance/upstream_head.py": {
+      "bytes": 714,
+      "sha256": "4c4f503c0ecef50d58b7a789f79f9336324c1548d9832e9ce75a675fd2ba302f"
+    },
+    "provenance/upstream_model_card.md": {
+      "bytes": 5234,
+      "sha256": "8f18acc423edf4c7db50d877f8f826ff6e019e6395092b800b6673db3e00cae2"
+    },
+    "requirements-mac.txt": {
+      "bytes": 184,
+      "sha256": "01b04c2acde4835455b18b65e8e3567c1a8d607f23692afb01f4a842487dd147"
+    },
+    "run_jeeves.py": {
+      "bytes": 9594,
+      "sha256": "5e381f42611ee195f4579eb3d3433abf7c292aecb26e52b6ccd94ecd4e13c654"
+    },
+    "tokenizer.json": {
+      "bytes": 19989325,
+      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"
+    },
+    "tokenizer_config.json": {
+      "bytes": 1161,
+      "sha256": "95c557768e6b88a7128befc7bfd3c7de50e5d51af9b8b33a9f4dee0e04f99679"
+    },
+    "validation.json": {
+      "bytes": 2250,
+      "sha256": "36d3a8cf620c7db74476f8f4f6d0c8ab77b225bb0d6b5c8859eb0d5bf57f5061"
+    }
+  }
+}

provenance/source_config.json

@@ -0,0 +1,61 @@
+{
+  "vocab_size": 248320,
+  "hidden_size": 4096,
+  "intermediate_size": 12288,
+  "num_hidden_layers": 32,
+  "layer_types": [
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention",
+    "linear_attention",
+    "linear_attention",
+    "linear_attention",
+    "full_attention"
+  ],
+  "tie_word_embeddings": false,
+  "num_attention_heads": 16,
+  "num_key_value_heads": 4,
+  "head_dim": 256,
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "linear_num_key_heads": 16,
+  "linear_num_value_heads": 32,
+  "linear_key_head_dim": 128,
+  "linear_value_head_dim": 128,
+  "linear_conv_kernel_dim": 4,
+  "rms_norm_eps": 1e-06,
+  "hidden_act": "silu",
+  "rope_theta": 10000000,
+  "partial_rotary_factor": 0.25,
+  "max_position_embeddings": 262144,
+  "pad_token_id": null,
+  "eos_token_id": 248044,
+  "bos_token_id": null,
+  "dtype": "bfloat16",
+  "initializer_range": 0.02
+}

provenance/source_lock.json

@@ -0,0 +1,7 @@
+{
+  "repo_id": "PostHog/jeeves",
+  "hf_revision": "8622b7d1652a9dcb8629486b84dce9e8d690c5cd",
+  "jeeves_code_sha": "f04ec5567301450dcaae0210dd54deeb4f647f87",
+  "mlx_lm_sha": "94cdcae13b266c337bcaca09b97b9c5a9c0e2cde",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa"
+}

provenance/source_shards.json

@@ -0,0 +1,27 @@
+{
+  "model-00001-of-00005.safetensors": {
+    "bytes": 4268059288,
+    "sha256": "c8d38178b51c845d6befca9e2c8a579889055cecf510fdbc85dbdf7bb867a0d6",
+    "hub_hash_verified": true
+  },
+  "model-00002-of-00005.safetensors": {
+    "bytes": 4266315424,
+    "sha256": "a25e1a608a5be9cadef95e3f40fdca5c17b6c21e86481186adfd7a8a1f5b8f40",
+    "hub_hash_verified": true
+  },
+  "model-00003-of-00005.safetensors": {
+    "bytes": 4215378072,
+    "sha256": "ab693e0b5940052ad04450fccfd12c87a49ce9ad23984bdfc07ee20d3ab654fe",
+    "hub_hash_verified": true
+  },
+  "model-00004-of-00005.safetensors": {
+    "bytes": 3123665648,
+    "sha256": "9942b7369222a4403809a05f1da21f53b006f2d5cf72651483dda48c4931ed9a",
+    "hub_hash_verified": true
+  },
+  "model-00005-of-00005.safetensors": {
+    "bytes": 2034237568,
+    "sha256": "dd63614f1dc80dce2d83be3f3e69af1f8a0ebc8add9b8e0abf3910f563e44344",
+    "hub_hash_verified": true
+  }
+}

provenance/torch_reference.json

@@ -0,0 +1,18 @@
+{
+  "status": "passed",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "device": "cpu",
+  "dtype": "bfloat16",
+  "fixture_sha256": "2887c941fd5a497ae51343a9e2382ea1d198ab5eb140f4e8c8fd37c54be4ebf0",
+  "cases": [
+    {
+      "id": "case0",
+      "probabilities": [
+        0.03340453281998634,
+        0.9665954113006592
+      ],
+      "elapsed_seconds": 22.900140517999716
+    }
+  ],
+  "scope": "No-thinking reference outputs; diagnostic timings, not a benchmark."
+}

provenance/torch_reference.npz

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

provenance/upstream_code.json

@@ -0,0 +1,13 @@
+{
+  "revision": "f04ec5567301450dcaae0210dd54deeb4f647f87",
+  "files": {
+    "model/__init__.py": "2792fa98fe4e980059445bc85755dcf830377427208ce6751fa7a2129e163897",
+    "model/model.py": "e827e20b3552e0c4632a6f413ff4e1cd4046adf0de12aaa92827095f625ec5ac",
+    "model/config.py": "a1732320888e15ff93bb612aa716e3fd2652dc5f09c9abcd2e6f5e43f34685c9",
+    "model/lora.py": "02602dfac5f2cddbbee53a5b9e558871a42c56f00c5c959f20ab17eb3317ad52",
+    "model/head.py": "4c4f503c0ecef50d58b7a789f79f9336324c1548d9832e9ce75a675fd2ba302f",
+    "prep/format.py": "1c421b0e2ba879f5799842b3a44350d1f1db117ead23c47c7b01a27e2139c664",
+    "loader/dataloader.py": "7d8a43ddcac427125bbe6b8aca9cfb3306aa1dbef6d7509bfed1a65a2d93b4d1",
+    "LICENSE": "823f556c20700f9a2f5e520c7d4eb3089f083fb19cf618cdbe08c08982f41b8e"
+  }
+}

provenance/upstream_dataloader.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import random
+import re
+from dataclasses import dataclass
+from functools import partial
+from typing import Sequence
+
+import torch
+from torch.utils.data import DataLoader, DistributedSampler
+from transformers import AutoTokenizer
+
+from prep.format import DataFormat, Question, read_jsonl
+
+STATE, Q, OPT, OPT_END, DECIDE = "<|fim_prefix|>", "<|fim_middle|>", "<|box_start|>", "<|box_end|>", "<|fim_suffix|>"
+THINK, THINK_END = "<think>", "</think>"
+CONTROL_RE = re.compile(r"<\|([A-Za-z0-9_]+)\|>")
+
+
+def sanitize(text: str) -> str:
+    return CONTROL_RE.sub(r"<¦\1¦>", text)
+
+
+@dataclass
+class Example:
+    prompt: list[int]
+    remainder: list[int]
+    label: int
+    target: list[float] | None
+    n_options: int
+    source: str
+    source_id: int
+    record_id: str
+    question_id: str
+    think: list[int] | None = None
+    plain_prompt: list[int] | None = None
+
+    @property
+    def full(self) -> list[int]:
+        return self.prompt + self.remainder
+
+
+@dataclass
+class Batch:
+    input_ids: torch.Tensor
+    attention_mask: torch.Tensor
+    opt_index: torch.Tensor
+    opt_mask: torch.Tensor
+    decide_index: torch.Tensor
+    labels: torch.Tensor
+    targets: torch.Tensor
+    source_ids: torch.Tensor
+    chain_mask: torch.Tensor
+    valid: torch.Tensor
+    group_ids: torch.Tensor
+    think_start: torch.Tensor
+    suffix_len: torch.Tensor
+    old_logp: torch.Tensor
+
+    def to(self, device, non_blocking: bool = True) -> "Batch":
+        return Batch(**{k: v.to(device, non_blocking=non_blocking) for k, v in self.__dict__.items()})
+
+    def pin_memory(self) -> "Batch":
+        return Batch(**{k: v.pin_memory() for k, v in self.__dict__.items()})
+
+    def __len__(self) -> int:
+        return self.input_ids.shape[0]
+
+
+@dataclass(frozen=True)
+class Markers:
+    pad_id: int
+    opt_end_id: int
+    think_end_id: int
+    empty_think: tuple[int, ...]
+    pad_multiple: int
+
+
+class Encoder:
+    FORMAT = "markers-v3-plainchains"
+
+    def __init__(self, tokenizer_repo: str = "Qwen/Qwen3.5-9B", pad_multiple: int = 128):
+        self.tok = AutoTokenizer.from_pretrained(tokenizer_repo)
+        self.pad_multiple = pad_multiple
+        ids = self.tok.convert_tokens_to_ids([STATE, Q, OPT, OPT_END, DECIDE, THINK, THINK_END])
+        if any(i is None or i == self.tok.unk_token_id for i in ids):
+            raise ValueError("marker tokens missing from tokenizer")
+        self.state_id, self.q_id, self.opt_id, self.opt_end_id, self.decide_id, self.think_id, self.think_end_id = ids
+        self.pad_id = self.tok.pad_token_id
+        special = set(self.tok.all_special_ids) | set(self.tok.get_added_vocab().values())
+        self.banned_ids = sorted(special - {self.think_end_id})
+        self.empty_think = self.encode("\n")
+
+    @property
+    def markers(self) -> Markers:
+        return Markers(self.pad_id, self.opt_end_id, self.think_end_id, tuple(self.empty_think), self.pad_multiple)
+
+    def encode(self, text: str) -> list[int]:
+        return self.tok(text, add_special_tokens=False).input_ids
+
+    @staticmethod
+    def option_block(q: Question) -> str:
+        return "".join(f"{OPT}{sanitize(o)}{OPT_END}\n" for o in q.options())
+
+    def chat(self, content: str) -> str:
+        return self.tok.apply_chat_template([{"role": "user", "content": content}], tokenize=False,
+                                            add_generation_prompt=True, enable_thinking=True)
+
+    def prompt_text(self, record: DataFormat, q: Question) -> str:
+        return self.chat(f"{STATE}{sanitize(record.state_text())}\n{Q}{sanitize(q.instruction_text())}\n{self.option_block(q)}")
+
+    def plain_prompt_text(self, record: DataFormat, q: Question) -> str:
+        options = "\n".join(sanitize(o) for o in q.options())
+        return self.chat(f"Context:\n{sanitize(record.state_text())}\n\nQuestion: {sanitize(q.instruction_text())}\n\nOptions:\n{options}")
+
+    def remainder_text(self, q: Question) -> str:
+        return f"{THINK_END}\n\n{self.option_block(q)}{DECIDE}"
+
+    def example(self, record: DataFormat, q: Question, source_id: int) -> Example:
+        prompt = self.encode(self.prompt_text(record, q))
+        remainder = self.encode(self.remainder_text(q))
+        if prompt[-2:] != self.encode(f"{THINK}\n") or remainder[0] != self.think_end_id or remainder[-1] != self.decide_id:
+            raise ValueError(f"unexpected layout for {record.id}/{q.id}")
+        if remainder.count(self.opt_end_id) != len(q.options()):
+            raise ValueError(f"option boundary count mismatch for {record.id}/{q.id}")
+        return Example(prompt=prompt, remainder=remainder, label=q.label_index(), target=q.target_vector(),
+                       n_options=len(q.options()), source=record.source, source_id=source_id, record_id=record.id,
+                       question_id=q.id, plain_prompt=self.encode(self.plain_prompt_text(record, q)))
+
+
+def build_examples(records: Sequence[DataFormat], encoder: Encoder, sources: dict[str, int], max_len: int,
+                   extra_len: int = 0) -> tuple[list[Example], int]:
+    out, dropped = [], 0
+    for r in records:
+        sid = sources.setdefault(r.source, len(sources))
+        for q in r.questions:
+            ex = encoder.example(r, q, sid)
+            if len(ex.prompt) + len(ex.remainder) + extra_len > max_len:
+                dropped += 1
+                continue
+            out.append(ex)
+    return out, dropped
+
+
+def load_examples(path: str, encoder: Encoder, sources: dict[str, int], max_len: int, extra_len: int = 0,
+                  limit: int = 0, seed: int = 0) -> tuple[list[Example], int]:
+    records = read_jsonl(path)
+    if limit and limit < len(records):
+        records = random.Random(seed).sample(records, limit)
+    return build_examples(records, encoder, sources, max_len, extra_len)
+
+
+def readout_positions(ids: list[int], m: Markers) -> tuple[list[int], int]:
+    start = len(ids) - 1 - ids[::-1].index(m.think_end_id)
+    opts = [i for i in range(start, len(ids)) if ids[i] == m.opt_end_id]
+    return opts, len(ids) - 1
+
+
+def padded_length(n: int, multiple: int) -> int:
+    return -(-n // multiple) * multiple if multiple > 1 else n
+
+
+@dataclass
+class CollateRow:
+    example: Example
+    input_ids: list[int]
+    group_id: int
+    closed: bool = True
+    chain_span: tuple[int, int] | None = None
+    logprobs: list[float] | None = None
+
+
+def collate(rows: list[CollateRow], m: Markers) -> Batch:
+    B = len(rows)
+    T = padded_length(max(len(row.input_ids) for row in rows), m.pad_multiple)
+    K = max(row.example.n_options for row in rows)
+    input_ids = torch.full((B, T), m.pad_id, dtype=torch.long)
+    attention_mask = torch.zeros(B, T, dtype=torch.long)
+    opt_index = torch.zeros(B, K, dtype=torch.long)
+    opt_mask = torch.zeros(B, K, dtype=torch.bool)
+    decide_index = torch.zeros(B, dtype=torch.long)
+    labels = torch.zeros(B, dtype=torch.long)
+    targets = torch.zeros(B, K, dtype=torch.float32)
+    source_ids = torch.zeros(B, dtype=torch.long)
+    chain_mask = torch.zeros(B, T, dtype=torch.bool)
+    valid = torch.zeros(B, dtype=torch.bool)
+    group_ids = torch.zeros(B, dtype=torch.long)
+    think_start = torch.zeros(B, dtype=torch.long)
+    suffix_len = torch.zeros(B, dtype=torch.long)
+    old_logp = torch.zeros(B, T, dtype=torch.float32)
+    for b, row in enumerate(rows):
+        ex, ids, chain = row.example, row.input_ids, row.chain_span
+        n = len(ids)
+        input_ids[b, :n] = torch.tensor(ids, dtype=torch.long)
+        attention_mask[b, :n] = 1
+        opts, decide = readout_positions(ids, m)
+        if len(opts) != ex.n_options:
+            raise ValueError(f"expected {ex.n_options} option boundaries, found {len(opts)} for {ex.record_id}")
+        opt_index[b, :ex.n_options] = torch.tensor(opts, dtype=torch.long) + b * T
+        opt_mask[b, :ex.n_options] = True
+        decide_index[b] = decide + b * T
+        labels[b] = ex.label
+        if ex.target is not None:
+            targets[b, :ex.n_options] = torch.tensor(ex.target, dtype=torch.float32)
+        else:
+            targets[b, ex.label] = 1.0
+        source_ids[b] = ex.source_id
+        if chain is not None:
+            chain_mask[b, chain[0]:chain[1]] = True
+        valid[b] = row.closed
+        group_ids[b] = row.group_id
+        think_start[b] = len(ex.prompt)
+        suffix_len[b] = len(ex.remainder)
+        if row.logprobs is not None and chain is not None:
+            span = chain[1] - chain[0]
+            old_logp[b, chain[0]:chain[1]] = torch.tensor(row.logprobs[:span], dtype=torch.float32)
+    return Batch(input_ids, attention_mask, opt_index, opt_mask, decide_index, labels, targets, source_ids,
+                 chain_mask, valid, group_ids, think_start, suffix_len, old_logp)
+
+
+def collate_sft(examples: list[Example], m: Markers) -> Batch:
+    rows = []
+    for i, ex in enumerate(examples):
+        if ex.think is None:
+            rows.append(CollateRow(example=ex, input_ids=ex.prompt + list(m.empty_think) + ex.remainder, group_id=i))
+        else:
+            chain, ok = split_chain(ex.think, m)
+            rows.append(CollateRow(example=ex, input_ids=ex.prompt + chain + ex.remainder, group_id=i, closed=ok))
+    return collate(rows, m)
+
+
+def collate_prompts(examples: list[Example], m: Markers, plain: bool = False) -> tuple[torch.Tensor, torch.Tensor]:
+    prompts = [ex.plain_prompt if plain else ex.prompt for ex in examples]
+    B, T = len(examples), padded_length(max(len(p) for p in prompts), m.pad_multiple)
+    input_ids = torch.full((B, T), m.pad_id, dtype=torch.long)
+    attention_mask = torch.zeros(B, T, dtype=torch.long)
+    for b, p in enumerate(prompts):
+        n = len(p)
+        input_ids[b, T - n:] = torch.tensor(p, dtype=torch.long)
+        attention_mask[b, T - n:] = 1
+    return input_ids, attention_mask
+
+
+def split_chain(generated: list[int], m: Markers) -> tuple[list[int], bool]:
+    if m.think_end_id in generated:
+        return generated[:generated.index(m.think_end_id)], True
+    return generated, False
+
+
+def collate_rollouts(examples: list[Example], generated: list[list[int]], group_ids: list[int], m: Markers,
+                     logprobs: list[list[float] | None] | None = None) -> Batch:
+    rows = []
+    for i, (ex, gen, group) in enumerate(zip(examples, generated, group_ids)):
+        chain, ok = split_chain(gen, m)
+        ids = ex.prompt + chain + ex.remainder
+        span = (len(ex.prompt), len(ex.prompt) + len(chain) + int(ok))
+        rows.append(CollateRow(example=ex, input_ids=ids, group_id=group, closed=ok, chain_span=span,
+                               logprobs=logprobs[i] if logprobs is not None else None))
+    return collate(rows, m)
+
+
+def make_loader(examples: list[Example], batch_size: int, m: Markers, shuffle: bool, rank: int = 0, world_size: int = 1,
+                seed: int = 0, drop_last: bool = True, num_workers: int = 2) -> DataLoader:
+    sampler = DistributedSampler(examples, num_replicas=world_size, rank=rank, shuffle=shuffle, seed=seed,
+                                 drop_last=drop_last) if world_size > 1 else None
+    return DataLoader(examples, batch_size=batch_size, shuffle=shuffle and sampler is None, sampler=sampler,
+                      collate_fn=partial(collate_sft, m=m), num_workers=num_workers, pin_memory=True, drop_last=drop_last,
+                      persistent_workers=num_workers > 0, generator=torch.Generator().manual_seed(seed))

provenance/upstream_head.py

@@ -0,0 +1,20 @@
+from torch import Tensor, nn
+
+
+class PointerHead(nn.Module):
+    def __init__(self, d_embed: int, d_latent: int = 256):
+        super().__init__()
+        self.q = nn.Linear(d_embed, d_latent)
+        self.k = nn.Linear(d_embed, d_latent)
+        self.scale = d_latent**-0.5
+        self.temperature = 1.0
+
+    def forward(
+        self, 
+        questions: Tensor, # (B, K, D) 
+        decide: Tensor # (B, D)
+    ) -> Tensor:
+        options = self.k(questions.to(self.k.weight.dtype))
+        query = self.q(decide.to(self.q.weight.dtype))
+        logits = (options @ query.unsqueeze(-1)).squeeze(-1) * self.scale
+        return logits if self.training or self.temperature == 1.0 else logits / self.temperature

provenance/upstream_model_card.md

@@ -0,0 +1,106 @@
+---
+license: apache-2.0
+base_model: Qwen/Qwen3.5-9B
+language:
+- en
+pipeline_tag: text-classification
+tags:
+- decision
+- calibration
+- reasoning
+- speculative-decoding
+- qwen3.5
+---
+
+# Jeeves-9B
+
+A Jev-like decision model that reasons before it decides. Give it a state (text or JSON) and yes/no, multiple-choice or rating questions; it writes a reasoning chain per question and returns a calibrated probability for every option.
+
+This repository holds the fused weights (Qwen3.5-9B with the LoRA merged), the pointer head, the fitted temperature, and two speculative-decoding drafters. It loads with the Jeeves code, not with `transformers`: the pointer head and the prompt format are part of the model.
+
+## Files
+
+| file | contents |
+|---|---|
+| `model-*.safetensors`, `config.json` | fused Qwen3.5-9B weights, bf16 |
+| `head.pt` | pointer head (query and key projections, 256-dim) |
+| `export.json` | temperature (1.859), prompt format, training step and config |
+| `tokenizer.json`, `vocab.json`, `merges.txt`, `tokenizer_config.json`, `chat_template.jinja` | Qwen3.5 tokenizer |
+| `drafter_k4.safetensors` | block-4 drafter, the serving default, bf16 |
+| `drafter_k8.safetensors` | block-8 drafter, faster for single-question requests, bf16 |
+| `drafter_k4.config.json`, `drafter_k8.config.json` | drafter training settings |
+| `LICENSE` | Apache-2.0, inherited from Qwen3.5-9B |
+
+## Usage
+
+```bash
+hf download PostHog/jeeves --local-dir jeeves-weights
+git clone https://github.com/PostHog/jeeves && cd jeeves
+python -m inference.serve --model ../jeeves-weights --drafter ../jeeves-weights/drafter_k4.safetensors --port 8009
+```
+
+```bash
+curl -s localhost:8009/v1/systemone -H 'content-type: application/json' -d '{
+  "state": "I was charged twice for one order.",
+  "questions": {
+    "billing": {"type": "noul", "instructions": "Is this about billing?"},
+    "tone": {"type": "choice", "instructions": "What is the customer'"'"'s tone?", "criteria": {"calm": null, "frustrated": null, "angry": null}}
+  }}'
+```
+
+The request and response follow Jev's `/v1/systemone` format. An optional `options` object sets `think`, `max_think` (truncate chains), `nothink_threshold` (skip thinking when the no-think answer is already confident) and `return_reasoning`. Serving needs a CUDA GPU; the FP8 kernel needs Hopper, and `--no-fp8` serves in bf16.
+
+## Results
+
+Accuracy with thinking, greedy, 2,560-token cap. Kev-9B and Jev numbers are the ones Kev publishes. JevBench uses the same 231 public items for every model (the sealed judge tier is not included); the other rows use the same sources with different items.
+
+| | Kev-9B | Jev | Jeeves-9B |
+|---|---|---|---|
+| Test overall (out-of-domain and held-out) | 0.822 | 0.857 | **0.889** |
+| MMLU-Pro and buried state | 0.579 | **0.800** | 0.746 |
+| JevBench, public tiers | 0.715* | 0.866 | **0.935** |
+| JevBench hard | 0.451* | 0.730 | **0.865** |
+
+\* Kev-8B (Qwen3); no Kev-9B JevBench result is published.
+
+Without thinking the model scores 0.804 on the Jeeves test split, against 0.840 with it. With the fitted temperature the no-think path has a top-label calibration error of 0.021 and 1.3% confident errors (wrong at p ≥ 0.9).
+
+Serving on one H100, 325 dev questions:
+
+| setting | accuracy | median / p90 latency |
+|---|---|---|
+| full thinking | 0.825 | 3.3 s / 17.1 s |
+| `max_think` 768, `nothink_threshold` 0.9 | 0.806 | 2.0 s / 5.6 s |
+| no thinking | 0.775 | about 0.3 s |
+
+## Training
+
+- **SFT.** LoRA r=16 on every projection plus the pointer head, 2 epochs on 19,126 questions from 12 public datasets and synthetic policy data; half the questions carry a reasoning chain sampled from the base model.
+- **CISPO.** 9,992 RL questions, 8 rollouts each, up to 2,560 thinking tokens. Reward is the probability of the correct option, discounted by up to 10% for long chains. The released checkpoint is step 402 of a 624-step schedule.
+- **Calibration.** One softmax temperature fitted on the dev set.
+- **Drafters.** Diffusion views of the frozen model, inspired by Orthrus, distilled by KL divergence on chains sampled from this model. At one question the block-4 drafter decodes 1.6× faster than graphed greedy decoding and the block-8 drafter 1.76×.
+
+A from-scratch reproduction with the released code matched this checkpoint within noise. The training code, dataset build scripts and pinned dataset revisions are in the GitHub repository.
+
+## Limitations
+
+- Knowledge questions trail Jev (MMLU 0.793 vs 0.900, MMLU-Pro 0.739 vs 0.840).
+- Thinking is slow at the tail (17 s at p90 with full chains); use `max_think` and `nothink_threshold` when latency matters.
+- About a third of full-length chains hit the token cap without closing; accuracy on those items is lower.
+- Evaluated on English inputs only.
+
+## License
+
+The weights are derived from Qwen3.5-9B and are released under its Apache-2.0 license (`LICENSE`). The Jeeves code is MIT licensed.
+
+## Citation
+
+```bibtex
+@software{waltz2026jeeves,
+  author = {Waltz, Nicholas P.},
+  title  = {Jeeves: Reasoning Improves Jev-like Decisions},
+  year   = {2026},
+  url    = {https://github.com/PostHog/jeeves},
+  note   = {Qwen3.5-9B decision model trained with SFT and CISPO, with a block-4 diffusion drafter}
+}
+```

requirements-mac.txt

@@ -0,0 +1,6 @@
+mlx==0.32.3
+mlx-lm @ git+https://github.com/ml-explore/mlx-lm.git@94cdcae13b266c337bcaca09b97b9c5a9c0e2cde
+transformers==5.17.0
+huggingface-hub==1.33.0
+numpy==2.5.3
+safetensors==0.8.0

run_jeeves.py

@@ -0,0 +1,180 @@
+"""MLX Jeeves runner: no-thinking decisions and optional ordinary greedy reasoning.
+
+This is a correctness-oriented runner, not a port of the CUDA speculative server.
+The pointer head stays FP32. Each question gets its own recurrent/KV cache.
+"""
+from __future__ import annotations
+import argparse
+import json
+import platform
+import sys
+import time
+from pathlib import Path
+import numpy as np
+import mlx.core as mx
+from mlx_lm import load
+
+# Keep the vendored, torch-free format modules next to this runner.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from dataformat import DataFormat
+from jeeves_format import Encoder, readout_positions
+
+
+def head_scores(weights, hidden, temperature):
+    if not np.isfinite(temperature) or temperature <= 0:
+        raise ValueError("The exported calibration temperature must be finite and positive.")
+    h = mx.array(hidden, dtype=mx.float32)
+    options = h[:-1] @ weights["k.weight"].T + weights["k.bias"]
+    query = h[-1] @ weights["q.weight"].T + weights["q.bias"]
+    raw = (options @ query) * (weights["q.weight"].shape[0] ** -0.5)
+    calibrated = raw / temperature
+    probabilities = mx.softmax(calibrated, axis=-1)
+    mx.eval(raw, calibrated, probabilities)
+    result = tuple(np.asarray(x, dtype=np.float32) for x in (raw, calibrated, probabilities))
+    if not all(np.isfinite(x).all() for x in result) or not np.isclose(result[2].sum(), 1.0, atol=1e-5):
+        raise FloatingPointError("Non-finite or invalid decision probabilities.")
+    return result
+
+
+class JeevesMLX:
+    def __init__(self, model_dir, *, device="auto", chunk_size=16, max_context=4096):
+        self.path = Path(model_dir).expanduser().resolve()
+        if device == "auto":
+            device = "gpu" if platform.system() == "Darwin" and mx.metal.is_available() else "cpu"
+        if device not in {"cpu", "gpu"}:
+            raise ValueError("device must be auto, cpu, or gpu")
+        if device == "gpu" and not mx.metal.is_available():
+            raise RuntimeError("This runner's GPU mode requires Apple Metal. Use --device cpu on Colab.")
+        mx.set_default_device(mx.cpu if device == "cpu" else mx.gpu)
+        self.device = device
+        self.chunk_size = int(chunk_size)
+        self.max_context = int(max_context)
+        if self.chunk_size < 1 or self.max_context < 1:
+            raise ValueError("chunk_size and max_context must be positive")
+        self.export = json.loads((self.path / "export.json").read_text())
+        self.temperature = float(self.export["temperature"])
+        self.encoder = Encoder(str(self.path), pad_multiple=1)
+        if self.encoder.FORMAT != self.export["format"]:
+            raise ValueError("The exported prompt format does not match the bundled encoder.")
+        self.model, _ = load(str(self.path), tokenizer_config={"trust_remote_code": False}, lazy=False)
+        self.lm = self.model.language_model
+        self.core = self.lm.model
+        self.model.eval()
+        self.head = {k: v.astype(mx.float32) for k, v in mx.load(str(self.path / "head.safetensors")).items()}
+        mx.eval(self.head)
+        if set(self.head) != {"q.weight", "q.bias", "k.weight", "k.bias"}:
+            raise ValueError("Unexpected pointer-head tensors")
+        self.max_context = min(self.max_context, self.lm.args.max_position_embeddings)
+
+    def _evaluate(self, tokens, cache):
+        h = self.core(mx.array(tokens, dtype=mx.int32)[None], cache=cache)
+        mx.eval(h, [entry.state for entry in cache])
+        return h
+
+    def score_tokens(self, ids, n_options, *, progress=False):
+        """Return selected final-normalized hidden states plus head probabilities."""
+        if not ids or len(ids) > self.max_context:
+            raise ValueError(f"Input length {len(ids)} exceeds cap {self.max_context}; no silent truncation.")
+        if ids[-1] != self.encoder.decide_id:
+            raise ValueError("The last token is not the Jeeves decision marker.")
+        opts, decide = readout_positions(ids, self.encoder.markers)
+        if len(opts) != n_options:
+            raise ValueError("Suffix option marker count mismatch")
+        positions = opts + [decide]
+        selected = {}
+        cache = self.lm.make_cache()
+        for start in range(0, len(ids), self.chunk_size):
+            end = min(start + self.chunk_size, len(ids))
+            h = self._evaluate(ids[start:end], cache)
+            for pos in positions:
+                if start <= pos < end:
+                    selected[pos] = np.asarray(h[0, pos - start].astype(mx.float32)).copy()
+            if progress:
+                print(f"  CPU prefill {end}/{len(ids)} tokens", flush=True)
+        hidden = np.stack([selected[pos] for pos in positions])
+        if not np.isfinite(hidden).all():
+            raise FloatingPointError("Non-finite hidden states")
+        raw, logits, probabilities = head_scores(self.head, hidden, self.temperature)
+        return {"hidden": hidden, "raw_logits": raw, "logits": logits, "probabilities": probabilities,
+                "option_positions": opts, "decide_position": decide}
+
+    def greedy_chain(self, prompt, budget):
+        """No speculative drafting. Stop before </think>; caller adds the suffix."""
+        if budget < 1 or len(prompt) + budget > self.max_context:
+            raise ValueError("Invalid reasoning budget or context overflow")
+        cache = self.lm.make_cache()
+        for start in range(0, len(prompt), self.chunk_size):
+            h = self._evaluate(prompt[start:start + self.chunk_size], cache)
+        banned = mx.array(self.encoder.banned_ids, dtype=mx.int32)
+        bias = mx.zeros((self.lm.args.vocab_size,), dtype=mx.float32)
+        bias[banned] = -1e4  # Same suppression magnitude as the upstream predictor.
+        chain = []
+        for _ in range(budget):
+            logits = (self.lm.model.embed_tokens.as_linear(h[:, -1]) if self.lm.args.tie_word_embeddings
+                      else self.lm.lm_head(h[:, -1]))
+            logits = logits.astype(mx.float32) + bias
+            token = int(mx.argmax(logits[0]).item())
+            if token == self.encoder.think_end_id:
+                return chain, True
+            chain.append(token)
+            h = self._evaluate([token], cache)
+        return chain, False
+
+    def predict(self, request, *, think_tokens=0):
+        if not isinstance(think_tokens, int) or isinstance(think_tokens, bool) or think_tokens < 0:
+            raise ValueError("think_tokens must be a nonnegative integer")
+        record = DataFormat.from_dict(request)
+        if len(record.questions) > 64:
+            raise ValueError("At most 64 questions per request in this reference runner")
+        results = {}
+        for question in record.questions:
+            keys = question.keys()
+            if not keys:
+                raise ValueError(f"Question {question.id} has no options")
+            prompt = self.encoder.encode(self.encoder.prompt_text(record, question))
+            suffix = self.encoder.encode(self.encoder.remainder_text(question))
+            if len(prompt) + max(think_tokens, len(self.encoder.empty_think)) + len(suffix) > self.max_context:
+                raise ValueError("Request plus reasoning/suffix exceeds max_context; shorten the request.")
+            started = time.perf_counter()
+            if think_tokens:
+                chain, closed = self.greedy_chain(prompt, think_tokens)
+            else:
+                chain, closed = list(self.encoder.empty_think), True
+            # Re-prefill the exact complete sequence for readout. Safe, but not latency-optimized.
+            scored = self.score_tokens(prompt + chain + suffix, len(keys))
+            p = scored["probabilities"]
+            results[question.id] = {
+                "type": question.type, "selected": keys[int(p.argmax())],
+                "probabilities": {key: float(value) for key, value in zip(keys, p)},
+                "input_tokens": len(prompt) + len(chain) + len(suffix),
+                "reasoning_tokens": len(chain) if think_tokens else 0,
+                "reasoning_closed": closed if think_tokens else None,
+                "reasoning": self.encoder.tok.decode(chain, skip_special_tokens=False) if think_tokens else None,
+                "elapsed_seconds": time.perf_counter() - started,
+            }
+        return {"model": "PostHog/jeeves (MLX port)", "device": self.device,
+                "mode": "greedy-thinking" if think_tokens else "no-thinking",
+                "temperature": self.temperature, "results": results}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", default=str(Path(__file__).resolve().parent))
+    parser.add_argument("--request", required=True, help="Path to a JSON state/questions object")
+    parser.add_argument("--output", default="")
+    parser.add_argument("--device", choices=["auto", "cpu", "gpu"], default="auto")
+    parser.add_argument("--chunk-size", type=int, default=16)
+    parser.add_argument("--max-context", type=int, default=4096)
+    parser.add_argument("--think-tokens", type=int, default=0)
+    args = parser.parse_args()
+    model = JeevesMLX(args.model, device=args.device, chunk_size=args.chunk_size, max_context=args.max_context)
+    request = json.loads(Path(args.request).read_text(encoding="utf-8"))
+    result = model.predict(request, think_tokens=args.think_tokens)
+    text = json.dumps(result, indent=2, ensure_ascii=False, allow_nan=False)
+    if args.output:
+        Path(args.output).write_text(text + "\n", encoding="utf-8")
+    print(text)
+
+
+if __name__ == "__main__":
+    main()

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,33 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "tool_parser_type": "qwen3_coder",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

validation.json

@@ -0,0 +1,67 @@
+{
+  "variant": "jeeves-mlx-4bit",
+  "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+  "conversion": "weights_converted_and_structurally_checked",
+  "format_head_checks": {
+    "status": "passed",
+    "format_cases": 4,
+    "original_head_dtypes": {
+      "q.weight": "torch.float32",
+      "q.bias": "torch.float32",
+      "k.weight": "torch.float32",
+      "k.bias": "torch.float32"
+    },
+    "exported_head_dtype": "float32",
+    "temperature": 1.8589280843734741,
+    "max_head_probability_error": 0.0,
+    "scope": "Original encoder token/readout parity, safe head serialization, and original PyTorch head vs MLX head on synthetic hidden states. Not backbone parity."
+  },
+  "cpu_smoke": {
+    "status": "passed",
+    "identity": "c4d0ea30e584dbf0d1e672c59c2e00036cb6a1a7025833ef49c01c63432b18fa",
+    "device": "cpu",
+    "cases": [
+      {
+        "id": "case0",
+        "probabilities": [
+          0.016998127102851868,
+          0.9830018877983093
+        ],
+        "elapsed_seconds": 4345.674271831
+      }
+    ],
+    "fixture_sha256": "2887c941fd5a497ae51343a9e2382ea1d198ab5eb140f4e8c8fd37c54be4ebf0",
+    "scope": "Small no-thinking execution smoke test; not a benchmark."
+  },
+  "bf16_backbone_parity": {
+    "status": "small_fixture_check_passed",
+    "cases": [
+      {
+        "id": "case0",
+        "maximum_probability_delta": 0.00010848045349121094,
+        "minimum_hidden_cosine": 0.9999632468948669,
+        "top_option_agreement": true,
+        "within_diagnostic_tolerances": true
+      }
+    ],
+    "probability_atol": 0.02,
+    "minimum_cosine": 0.995,
+    "scope": "Heuristic diagnostic tolerances, not bitwise equivalence or general accuracy evidence."
+  },
+  "apple_metal_validation": "not_run",
+  "task_accuracy_calibration_benchmark": "not_run",
+  "speculative_drafters": "not_ported",
+  "greedy_generation_validation": "not_run",
+  "quantization_vs_mlx_bf16": {
+    "cases": [
+      {
+        "id": "case0",
+        "maximum_probability_delta": 0.016297996044158936,
+        "top_option_agreement": true
+      }
+    ],
+    "status": "measured_not_quality_certified"
+  },
+  "overall_status": "converted_and_small_cpu_diagnostics_passed_not_benchmarked",
+  "diagnostic_failures": []
+}