Make MLX adapter-only and include the reproducible BF16 converter

The MLX setup reads the root adapter and heads, downloads the pinned Qwen base
separately, and assembles a verified local BF16 model. Includes the exact historical
converter, locked dependencies, source, integrity tests, setup instructions and dated
CUDA-parity status. No new temperature fitting; complete held-out parity remains
pending.

mlx/.gitignore

@@ -0,0 +1,12 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+snapshots/
+models/
+evaluations/
+*.log
+
+document-replay.json
+dist/

mlx/CONVERTER-SOURCE.json

@@ -0,0 +1,21 @@
+{
+  "converter_code_sha256": "bbcae17fc1c35db80a79d5865133a42ef9a1b0cf342fff71949972e69cce43ec",
+  "files": {
+    "__init__.py": "714a5439b33780d250c404938cd062c0d6809f83f21b59f89997bd168469925a",
+    "_vendor/__init__.py": "77defd15cc47661e0e9a31275e7fd59e979f3f9a6429671d8199f6002dca6c2c",
+    "_vendor/contract.py": "7c6607179a028f30b462349a86f9cf7d0ec2652e0a1c7c8c24649b6ce71df697",
+    "_vendor/evidence.py": "18a4978a27d6bbd3f7daaa34836d1820303c4ff581b0dfda877aab586392293b",
+    "_vendor/evidence_v3.py": "6ff3da1e920c082e9b3629ca0230007262f2ce69fd921b89dd4b3e67511b3a64",
+    "_vendor/prompts.py": "8bfb5a12d625664c8830f5cf243aac04d1e973bfe4f5ecfc8221021f09c318df",
+    "_vendor/retrieval.py": "11e7bbb1a84ba837eac3768d6e882f44a557be25d62729c8a39dd5cb870c0932",
+    "_vendor/semantics.py": "b580d3c114536a6faf58bcd92d2c61028f80891a19d78d6a17ed585948abfc15",
+    "api.py": "bae9fdd3ef6b395142ec5c099635cc9ba90f7f33c7423f99caf6009f51d4fd3c",
+    "artifacts.py": "d41d4d3f19aaf0dd54e4503d43807a29208d9528b8d4734b9f3d99cad18d9f93",
+    "budget.py": "f72614686c19e1d923e6bc23d4353e8b1ac150863565939ae4a3831bc4ecd211",
+    "cli.py": "0a6be4cd03621963ec5f73a8af71224cb8b40ae88232477d8370b7d3b9b75021",
+    "engine.py": "13c27c3fbca576ae0d70262c2a75c9382df3b4fcfd8a11996d125750883b648a",
+    "evaluation.py": "bb9f50d184527e21139b9ffb5e9d1613bc30822ccd7cf06b7b7f8b1cc8b50674",
+    "prepare.py": "dda9879a9ddc1c3f6dcf0df52b3a244b2ca7920946bbd29ddc8e1c0f9944b887"
+  },
+  "schema": "solomon-mlx-converter-source-v1"
+}

mlx/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 Doccy Pty Ltd
+
+   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.

mlx/MODIFICATIONS.md

@@ -0,0 +1,25 @@
+# Solomon MLX modifications
+
+This port adapts Doccy Pty Ltd’s Apache-2.0 Solomon source at revision
+`2ec506902269e4636285c8811f6c0f52c9300c0c`. Original modification notices are preserved in
+`docs/UPSTREAM-MODIFICATIONS.md`.
+
+Changes:
+
+- Replaced CUDA execution with MLX-VLM Qwen3.5 execution for the declared Qwen3.8 architecture.
+- Added BF16 shard conversion with FP32 normalization parameters, adapter, trained heads and recurrent states.
+- Replaced global adapter state with instance-owned state and isolated question cache containers.
+- Removed vocabulary projection from decision inference.
+- Added a document-state API, replay recipes, artifact checksums and MLX-specific runtime identities.
+- Extracted the original prompts, question contract, semantics and evidence utilities into `_vendor`.
+- Implemented the documented ordering-score product locally because the release omits `scope9.reliability`.
+- Added download, CUDA parity comparison, benchmark and test tools. New temperature fitting is outside the current scope.
+
+No claim is made that this port inherits CUDA calibration or qualification. See
+`docs/VALIDATION-20260921.md` for measured results and outstanding validation.
+
+Adapter-only distribution update (21 September 2026): added a separate verified Hub
+loader, atomic local assembly and cache reuse; retained the exact historical converter
+source and FP32 normalization handling. Base weights are downloaded from the pinned
+Qwen repository. Duplicate adapter/head files under `mlx/bf16` are replaced by the
+root `adapter/` copies. CUDA parity status is reported separately from conversion.

mlx/NOTICE

@@ -0,0 +1,78 @@
+Solomon v1.1.0
+Copyright 2026 Doccy Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this work except in compliance with the License. You may obtain a copy of the
+License in the LICENSE file distributed with this work, or at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+--------------------------------------------------------------------------------
+ATTRIBUTION FOR THE BASE MODEL (Apache License 2.0, section 4(c))
+--------------------------------------------------------------------------------
+
+This work is a DERIVATIVE WORK of:
+
+    Qwen/Qwen3.8-27B
+    Copyright 2026 Alibaba Cloud
+    Licensed under the Apache License, Version 2.0
+    Pinned revision: 1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0
+    Licence text: licenses/Qwen-Apache-2.0.txt (sha256 bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a, 11544 bytes,
+      the exact bytes served at the pinned revision)
+
+The base model weights are NOT redistributed in this repository. They are
+referenced by the pinned revision above and downloaded by the operator directly
+from the upstream repository under the upstream licence.
+
+Upstream NOTICE file: NONE. A NOTICE file is absent from Qwen/Qwen3.8-27B at the
+pinned revision (HTTP 404, retrieved 2026-09-18T03:49Z without credentials).
+Apache-2.0 section 4(d) therefore imposes no carry-forward obligation here. No
+upstream attribution text has been invented or paraphrased.
+
+"Qwen" and "Alibaba Cloud" are used nominatively, to identify the base model
+this adapter was trained against. Apache-2.0 section 6 grants no trademark
+rights and none are claimed or implied. Nothing here states or implies any
+endorsement, sponsorship or affiliation.
+
+--------------------------------------------------------------------------------
+STATEMENT OF CHANGES (Apache License 2.0, section 4(b))
+--------------------------------------------------------------------------------
+
+No upstream source file is modified, and no upstream file is redistributed
+except the unmodified licence text at licenses/Qwen-Apache-2.0.txt.
+
+The modification this work carries is a trained LoRA adapter and a set of
+trained linear answer heads, applied to the base model at inference time:
+
+  * LoRA adapter, rank 64, question-side placement, float32
+      adapter/adapter.safetensors
+      sha256 2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca
+      870363376 bytes
+  * Trained linear answer heads
+      adapter/heads.npz
+      sha256 126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f
+      2053938 bytes
+  * Readout calibration (one positive scalar per task)
+      serving/scope9-readout-temperature-v2.json
+      file sha256 baa7263ca9e865dda230617563e6a615de5050adc620c28924dffef68d527118
+      payload sha256 682d611ec53c3322905c7e265bf9b9b35a1cd581f6d8b7ea924df864a3d74278
+
+Training took place between 16 and 20 September 2026. The adapter and the heads
+are identified by the checksums above. Full change detail is in MODIFICATIONS.md.
+
+--------------------------------------------------------------------------------
+THIRD-PARTY CONTENT IN THIS REPOSITORY
+--------------------------------------------------------------------------------
+
+The only third-party content distributed here is the unmodified Apache License
+2.0 text at licenses/Qwen-Apache-2.0.txt, reproduced to satisfy section 4(a).
+
+No training document, evaluation panel, dataset, corpus, rendered page, cached
+state, score archive or acceptance fixture is distributed. Every file in this
+repository was scanned for text originating in third-party source documents
+before release; see MODIFICATIONS.md, "Third-party text scan".
+
+Everything else in this repository -- the serving code under src/, the adapter
+and head weights, the calibration artifact, the serving binding and the
+documentation -- is original work of Doccy Pty Ltd, licensed under
+Apache-2.0.

mlx/README.md

@@ -0,0 +1,146 @@
+# Solomon MLX
+
+Full BF16 Solomon v1.1 inference on Apple Silicon. The repository distributes
+adapters and source code; the Qwen backbone is downloaded separately from its
+pinned upstream revision and converted locally. No quantization or LoRA merging
+is performed. Full-model measurements use an M5 Max with 128 GB memory, with
+about 59.9 GB peak Metal allocation on the focused fixtures. Longer documents
+and more images require additional memory; 24–32 GB Macs cannot run this profile.
+
+**Status: experimental.** Focused text and image decisions match CUDA. Complete
+held-out parity remains pending. Qualification is CUDA parity only: no new
+calibration or temperature fitting. See [validation results](docs/VALIDATION-20260921.md).
+
+## Install from this repository
+
+Use Python 3.12 or 3.13 on Apple Silicon. Pin the full repository commit shown on
+Hugging Face, including after any repository history rewrite. The historical
+Solomon source revision remains provenance; it is not required to be downloadable.
+
+```sh
+# From a source checkout, enter its mlx/ directory first.
+uv sync --frozen --extra dev
+
+# Obtain the current commit once, then retain it for repeatable downloads.
+SOLOMON_COMMIT=$(uv run python -c 'from huggingface_hub import HfApi; print(HfApi().model_info("DoccyHealth/Solomon").sha)')
+uv run solomon-mlx-hub prepare --revision "$SOLOMON_COMMIT" --output models/quality
+```
+
+Authenticate with `hf auth login` first if the repository requires access. This
+package is supplied here as source; it is not claimed to be published on PyPI.
+For a checkout without downloading model files through Git LFS:
+
+```sh
+GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/DoccyHealth/Solomon
+cd Solomon/mlx
+```
+
+The setup tool explicitly fetches `adapter/**` and the retained MLX licensing
+metadata. It downloads `Qwen/Qwen3.8-27B` at
+`1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0`, verifies every input against the
+bundled manifest, and converts one shard at a time. Budget about 112 GB of disk
+for original and converted weights, plus temporary space and caches. Existing
+original base files can be reused with `--base /path/to/original-qwen`.
+
+The output contains `backbone/`, the unmerged adapter, trained heads, notices
+and a fresh `binding.json`. Existing valid outputs are verified and reused;
+corrupt or incompatible outputs fail without being overwritten. Conversion is
+atomic and concurrent preparations into the same output are rejected. Interrupted
+conversions may leave a hidden temporary directory; the final output is never
+marked ready before verification completes.
+
+For fully offline preparation, provide both downloaded inputs:
+
+```sh
+uv run solomon-mlx-hub prepare --revision "$SOLOMON_COMMIT" \
+  --snapshot /path/to/solomon-snapshot --base /path/to/original-qwen \
+  --output models/quality
+uv run solomon-mlx-hub verify models/quality
+```
+
+CPU conversion is the default. `--device gpu` selects Metal conversion on a Mac.
+Linux CPU conversion is also supported by the existing converter and can use
+`uv sync --frozen --extra cloud` with MLX's CPU backend. Linux conversion does
+not run Apple Metal inference or establish CUDA parity.
+
+## Converter and provenance
+
+The exact converter is [src/solomon_mlx/prepare.py](src/solomon_mlx/prepare.py).
+The runtime Python sources are unchanged in behaviour. The only edits made for
+this release rename the runtime identity's `source_contract` field to `solomon-v1`
+and adjust comments, docstrings and one error message, so their combined
+`converter_code_sha256` is
+`bbcae17fc1c35db80a79d5865133a42ef9a1b0cf342fff71949972e69cce43ec`.
+It is computed by `solomon_mlx.artifacts.code_identity()` from the sorted mapping
+of relative Python paths to SHA-256 values. The new download/assembly wrapper is
+in the separate `solomon_mlx_hub` package.
+
+The converter retains large weights in BF16 and promotes normalization weights,
+`A_log` and `dt_bias` to FP32 **before** applying upstream normalization offsets.
+It validates tensor names and shapes with MLX-VLM's Qwen3.5 implementation. The
+original FP32 adapter and ten trained heads are copied without changes. The
+runtime applies the adapter only to question tokens, with its explicit 2.0 scale.
+
+`bf16/conversion.json` and `bf16/binding.json` describe the historical cloud
+conversion; paths inside them describe the original local model layout. They
+are provenance, not a manifest of files currently present on the Hub, and they
+record the converter hash of that historical conversion, `648e440cface0838f2dcc8d89b3ab172d97f4ffc1f88fe0b7cbbe3ca73b8a575`,
+which predates the documentation edits described above. The root
+adapter files have the same hashes as their removed duplicates. Newly converted
+safetensors may serialize differently across CPU and Metal, so new outputs get
+actual output checksums and their own runtime binding. Historical CUDA or MLX
+qualification identities are never reused for a different artifact binding.
+
+## Python API
+
+```python
+from solomon_mlx import Solomon
+
+model = Solomon.load("models/quality", profile="quality")
+with model.prefill("Rookwood Ltd holds a current certification.") as state:
+    result = model.decide(
+        state=state,
+        questions={"certified": {
+            "type": "noul",
+            "instructions": "Does Rookwood Ltd hold a current certification?",
+        }},
+        evidence="support",
+    )
+    print(result["answers"]["certified"])
+```
+
+Or use `solomon_mlx_hub.load("models/quality", revision=COMMIT)` to prepare and
+load in one call. `revision` must be a full 40-character commit SHA. Cached valid
+outputs are reused without network access and retain their original binding.
+
+Documents accept text, structured JSON objects, or ordered `{"text": ...}` and
+`{"image": local_path}` parts. Image features are computed once per document.
+There is no PDF renderer or OCR. Question forms preserve Boolean, entity and
+multilabel `noul`, single `choice`, and ordered `score` semantics; candidate order
+is retained. Missing/conflicting facts collapse before temperature application.
+The API defaults to T=1. No new temperatures are fitted by setup or parity checks.
+
+Evidence levels are `none`, `support`, `sufficiency`, and `removal`. Text spans use
+exact code-point offsets. Sufficiency and removal re-encode the relevant source;
+they do not establish causal faithfulness. Image evidence requires `page_selector=`;
+otherwise the result reports `unsupported_page_selector`. States belong to one
+model instance and support `close()`, `save(path)`, and `model.replay(path)`.
+Replay persists a checksummed source recipe and recomputes caches.
+
+## Tests
+
+```sh
+uv run pytest -q
+uv run ruff check src tests scripts
+```
+
+Tests use synthetic small models to cover conversion precision, CPU/Metal tensor
+agreement, cache isolation, text/image processing, answer semantics, evidence,
+artifact corruption, and adapter-only setup. These tests do not replace trained
+model parity measurements. The included parity checker compares saved CUDA and
+MLX scores using the same frozen temperatures exactly once, reports probability
+drift separately, and cannot pass a complete-panel gate from partial results.
+Evaluation inputs and private infrastructure configuration are not distributed.
+
+Preserve `LICENSE`, `NOTICE`, `MODIFICATIONS.md`, and upstream model notices with
+permitted copies. Model downloads and conversion do not alter repository visibility.

mlx/bf16/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 Doccy Pty Ltd
+
+   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.

mlx/bf16/MODIFICATIONS.md

@@ -0,0 +1,75 @@
+# Statement of changes
+
+Apache License 2.0, section 4(b): prominent notice that files carry modifications.
+
+## What is modified
+
+**No upstream source file is modified.** No file from `Qwen/Qwen3.8-27B` is edited,
+renamed, patched or redistributed in this repository, with one exception: the
+upstream licence text is reproduced byte-for-byte at `licenses/Qwen-Apache-2.0.txt`
+(sha256 `bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a`) because section 4(a) requires it. That file is
+unmodified and carries the upstream copyright.
+
+The modification this work carries is not an edit to a source file. It is a set
+of **trained parameters applied to the base model at inference time**, plus an
+original serving layer that reads the model's logits. Concretely:
+
+| Change | Artifact | sha256 |
+|---|---|---|
+| LoRA adapter, rank 64, question-side placement, float32 | `adapter/adapter.safetensors` | `2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca` |
+| Trained linear answer heads | `adapter/heads.npz` | `126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f` |
+| Readout calibration, one positive scalar per task | `serving/scope9-readout-temperature-v2.json` | file `baa7263ca9e865dda230617563e6a615de5050adc620c28924dffef68d527118` / payload `682d611ec53c3322905c7e265bf9b9b35a1cd581f6d8b7ea924df864a3d74278` |
+| Runtime identity binding | `serving/serving-binding.json` | payload `95683c1f87ec3f71b7657669dc311918ff53b7d41a981eaa8d827047e72cb505` |
+| Serving layer (original work, not derived from upstream code) | `src/` | see `MANIFEST.json` |
+
+Base model, unmodified and not redistributed: `Qwen/Qwen3.8-27B` at revision
+`1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0`, Copyright 2026 Alibaba Cloud, Apache-2.0.
+
+Training took place between 16 and 20 September 2026. The shipped artifacts are
+identified by the checksums in the table above and in `MANIFEST.json`.
+
+## Which files carry a change notice
+
+| File | Why |
+|---|---|
+| `NOTICE` | Section 4(b) and 4(c) statement, carried with every copy |
+| `MODIFICATIONS.md` | this file |
+| `README.md` | names the base model, the pinned revision and the derivative relationship in the front matter and in the body |
+| `adapter/config.json` | machine-readable record of the base repo, the pinned revision and both weight checksums |
+| `serving/serving-binding.json` | pins the exact runtime the weights were measured on and refuses to load against a different one |
+
+No file under `src/` carries an upstream change notice, because no file under
+`src/` contains upstream code. Every file there is original work, written for
+this project, and is covered by the repository's own Apache-2.0 `LICENSE` and by
+the copyright line in `NOTICE`.
+
+All of the changes described above — the adapter, the heads, the calibration, the
+serving binding and the serving layer — are Copyright 2026
+Doccy Pty Ltd and licensed under Apache-2.0.
+
+## Third-party text scan
+
+Before release, **every file staged into this repository was scanned for text
+originating in third-party source documents.** The scan compared normalised
+6-gram and 8-gram shingles of every staged text file against:
+
+1. the 42 third-party source records the training and evaluation panels were
+   built from (Apache-2.0, MIT, BSD-3-Clause, CC BY 4.0, CC BY-SA 4.0, CC0,
+   OGL v3.0 and US-government public-domain assertions); and
+2. every generated panel and document corpus on disk.
+
+**Result: no third-party document text is present in any shipped file.** The
+only matches were:
+
+* the reproduced Apache-2.0 licence text at `licenses/Qwen-Apache-2.0.txt`, which
+  matches an Apache-2.0 licence document held in the evaluation corpus and is
+  required to be here verbatim; and
+* the phrase *"A missing fact is not a negative fact"*, which is **our own
+  prompt-template wording** appearing in our own evaluation panels, not
+  third-party text entering our prompts.
+
+Acceptance fixtures are excluded from this repository entirely. The fixture
+documents used in live acceptance are original synthetic text authored for this
+project and held in tooling that is not distributed.
+
+Re-run the scan with `ops/solomon_package.py --scan` in the source project.

mlx/bf16/NOTICE

@@ -0,0 +1,78 @@
+Solomon v1.1.0
+Copyright 2026 Doccy Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this work except in compliance with the License. You may obtain a copy of the
+License in the LICENSE file distributed with this work, or at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+--------------------------------------------------------------------------------
+ATTRIBUTION FOR THE BASE MODEL (Apache License 2.0, section 4(c))
+--------------------------------------------------------------------------------
+
+This work is a DERIVATIVE WORK of:
+
+    Qwen/Qwen3.8-27B
+    Copyright 2026 Alibaba Cloud
+    Licensed under the Apache License, Version 2.0
+    Pinned revision: 1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0
+    Licence text: licenses/Qwen-Apache-2.0.txt (sha256 bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a, 11544 bytes,
+      the exact bytes served at the pinned revision)
+
+The base model weights are NOT redistributed in this repository. They are
+referenced by the pinned revision above and downloaded by the operator directly
+from the upstream repository under the upstream licence.
+
+Upstream NOTICE file: NONE. A NOTICE file is absent from Qwen/Qwen3.8-27B at the
+pinned revision (HTTP 404, retrieved 2026-09-18T03:49Z without credentials).
+Apache-2.0 section 4(d) therefore imposes no carry-forward obligation here. No
+upstream attribution text has been invented or paraphrased.
+
+"Qwen" and "Alibaba Cloud" are used nominatively, to identify the base model
+this adapter was trained against. Apache-2.0 section 6 grants no trademark
+rights and none are claimed or implied. Nothing here states or implies any
+endorsement, sponsorship or affiliation.
+
+--------------------------------------------------------------------------------
+STATEMENT OF CHANGES (Apache License 2.0, section 4(b))
+--------------------------------------------------------------------------------
+
+No upstream source file is modified, and no upstream file is redistributed
+except the unmodified licence text at licenses/Qwen-Apache-2.0.txt.
+
+The modification this work carries is a trained LoRA adapter and a set of
+trained linear answer heads, applied to the base model at inference time:
+
+  * LoRA adapter, rank 64, question-side placement, float32
+      adapter/adapter.safetensors
+      sha256 2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca
+      870363376 bytes
+  * Trained linear answer heads
+      adapter/heads.npz
+      sha256 126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f
+      2053938 bytes
+  * Readout calibration (one positive scalar per task)
+      serving/scope9-readout-temperature-v2.json
+      file sha256 baa7263ca9e865dda230617563e6a615de5050adc620c28924dffef68d527118
+      payload sha256 682d611ec53c3322905c7e265bf9b9b35a1cd581f6d8b7ea924df864a3d74278
+
+Training took place between 16 and 20 September 2026. The adapter and the heads
+are identified by the checksums above. Full change detail is in MODIFICATIONS.md.
+
+--------------------------------------------------------------------------------
+THIRD-PARTY CONTENT IN THIS REPOSITORY
+--------------------------------------------------------------------------------
+
+The only third-party content distributed here is the unmodified Apache License
+2.0 text at licenses/Qwen-Apache-2.0.txt, reproduced to satisfy section 4(a).
+
+No training document, evaluation panel, dataset, corpus, rendered page, cached
+state, score archive or acceptance fixture is distributed. Every file in this
+repository was scanned for text originating in third-party source documents
+before release; see MODIFICATIONS.md, "Third-party text scan".
+
+Everything else in this repository -- the serving code under src/, the adapter
+and head weights, the calibration artifact, the serving binding and the
+documentation -- is original work of Doccy Pty Ltd, licensed under
+Apache-2.0.

mlx/bf16/README.md

@@ -0,0 +1,51 @@
+# Solomon BF16 conversion provenance
+
+This directory retains metadata for the unquantized BF16 conversion. **Backbone
+weights are downloaded separately from Qwen; adapter and head weights live at
+`adapter/adapter.safetensors` and `adapter/heads.npz` in the repository root.**
+This directory is no longer a self-contained loadable model.
+
+Install the source package in [`../`](../) and follow its README. From that
+package directory:
+
+```sh
+uv sync --frozen --extra dev
+SOLOMON_COMMIT=$(uv run python -c 'from huggingface_hub import HfApi; print(HfApi().model_info("DoccyHealth/Solomon").sha)')
+uv run solomon-mlx-hub prepare --revision "$SOLOMON_COMMIT" --output models/quality
+```
+
+The loader fetches `adapter/**` plus MLX licensing metadata at the pinned Solomon
+commit. It obtains the original base from `Qwen/Qwen3.8-27B` at
+`1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0`, verifies every base file, and invokes
+the included exact converter. Existing original weights can be supplied with
+`--base`. Existing valid converted outputs are verified and reused.
+
+The original converter source is `../src/solomon_mlx/prepare.py`. The runtime
+source hash recorded in `conversion.json` for this historical conversion is
+`648e440cface0838f2dcc8d89b3ab172d97f4ffc1f88fe0b7cbbe3ca73b8a575`. The
+current runtime source hash is
+`bbcae17fc1c35db80a79d5865133a42ef9a1b0cf342fff71949972e69cce43ec`;
+the two differ only by the release documentation edits described in `../README.md`,
+which changed no converter behaviour. The new Hub loader is packaged separately so the original
+converter remains reproducible. Dependency versions are locked in `../uv.lock`.
+Large matrices stay BF16; normalization parameters, `A_log`, and `dt_bias` stay
+FP32, with normalization offsets applied after promotion. LoRA is never merged.
+
+`conversion.json` and `binding.json` retain the historical output checksums and
+paths, including removed backbone and duplicate adapter paths. The root adapter
+and heads are byte-identical to those historical records. The old binding SHA-256
+is `6d45715aa040fad98b061ff2cbafb35b047143ef2475646cee3df7a334f4d530`.
+New local conversions receive a fresh binding with actual output checksums;
+safetensors serialization may differ across CPU and Metal. The historical source
+revision `2ec506902269e4636285c8811f6c0f52c9300c0c` is provenance, not a required
+future download URL. After a history rewrite, pin the new repository commit.
+
+**Experimental: complete CUDA parity remains pending.** Focused text/image
+fixtures and a partial text panel match CUDA decisions. See the dated results in
+`../docs/VALIDATION-20260921.md`. No new calibration or temperature fitting is
+required or performed. Existing CUDA temperatures are applied identically to both
+backends for comparison; CUDA qualification is not inherited.
+
+The historical conversion produced 55,610,774,146 bytes. Focused inference used
+about 59.9 GB peak Metal allocation on an M5 Max / 128 GB Mac; larger inputs need
+more memory. This is full BF16, without quantization, and does not fit 24–32 GB Macs.

mlx/bf16/base-manifest.json

@@ -0,0 +1,197 @@
+{
+  "revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+  "files": [
+    {
+      "name": ".gitattributes",
+      "size": 1570,
+      "blob_id": "52373fe24473b1aa44333d318f578ae6bf04b49b",
+      "sha256": null
+    },
+    {
+      "name": "LICENSE",
+      "size": 11544,
+      "blob_id": "f938136e3adacfd92be087f6e113b5d6d97f678f",
+      "sha256": null
+    },
+    {
+      "name": "README.md",
+      "size": 65012,
+      "blob_id": "bc8aa0e396cd029c21cd773cca21830d0ded28ec",
+      "sha256": null
+    },
+    {
+      "name": "chat_template.jinja",
+      "size": 8952,
+      "blob_id": "c0c686f9c38d70d179fb7b5f5aa7530bc913dda3",
+      "sha256": null
+    },
+    {
+      "name": "config.json",
+      "size": 4312,
+      "blob_id": "706cebd746c4b6f2b1d1f892630867acfdfd3df8",
+      "sha256": null
+    },
+    {
+      "name": "crc32.txt",
+      "size": 238,
+      "blob_id": "6de5ee6a0c6596744baee911af0a5cdcb8d99a1e",
+      "sha256": null
+    },
+    {
+      "name": "generation_config.json",
+      "size": 202,
+      "blob_id": "023756cfadf88e5bf69eefeee3e172f38c448d64",
+      "sha256": null
+    },
+    {
+      "name": "merges.txt",
+      "size": 3353259,
+      "blob_id": "a494e019ca1502219fd0128658b979e5f05ae8e8",
+      "sha256": null
+    },
+    {
+      "name": "model-00001-of-00018.safetensors",
+      "size": 3966730552,
+      "blob_id": "79b73cdd69afeca931d181f5d1e21ad2d73bb7b7",
+      "sha256": "ba0ce20aae489ad196733da5064bcdf159a1fe84f53336648196e1ebb7751b1c"
+    },
+    {
+      "name": "model-00002-of-00018.safetensors",
+      "size": 3043080328,
+      "blob_id": "81cf43545884a227a01351942dfbc72577812316",
+      "sha256": "06a148c01bfbe3faa14a5f184a7ff29a706f7ae1c8b2705d2058e26d17a001fb"
+    },
+    {
+      "name": "model-00003-of-00018.safetensors",
+      "size": 2542796952,
+      "blob_id": "a2da5e6cd6307a6cae13d04820ab0d31b47b48bd",
+      "sha256": "2e1bf62cbcd406eaa64b60d10353e1f0ef4039d0976e56f05cabe953454f9968"
+    },
+    {
+      "name": "model-00004-of-00018.safetensors",
+      "size": 3988973152,
+      "blob_id": "175ddab3f2488ad181f73d789d2d778cf6d4fca6",
+      "sha256": "511e34063187882659753c4d93f3859f93c019fd438d8813071921c81d9a3f1a"
+    },
+    {
+      "name": "model-00005-of-00018.safetensors",
+      "size": 2099339864,
+      "blob_id": "64890208fdd563c3aac0c2f55f69948bcaa1a492",
+      "sha256": "635cb53446dc74f219740fc59e18b774f877b803b9722e289ca62575a6efa701"
+    },
+    {
+      "name": "model-00006-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "3ae29b86e4c773babfe17124dbd10d54d37819ec",
+      "sha256": "0bc5214fac607f0e6cc92eec3789d4b8559410ef9fce66621ba8158e8410dae0"
+    },
+    {
+      "name": "model-00007-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "b7e9c0f038884839f3dad38fef7e75ee3362c24f",
+      "sha256": "80b0c49033e9a0d5762562aa12f4acdb7f54da586f3d0110f28c48d91cf07892"
+    },
+    {
+      "name": "model-00008-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "0b58cbc52714e1c683711be87e7c2e33fb10e7a0",
+      "sha256": "7192c5b66185d3592927daabee1cc19e6f6e0ce75988ee20e824b624765fda79"
+    },
+    {
+      "name": "model-00009-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "4fc0c6b28004d809225d0e115f30e9e11c2345dc",
+      "sha256": "af3c48cc37af44f3db6ae0579baf019180d48d9c527caa0a1f03ff85813a56d8"
+    },
+    {
+      "name": "model-00010-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "9ec693a17c788084116c51b4f34632670df77612",
+      "sha256": "163490a76f3bea3a40855b7efc04ce6d27afaf1a34f0bbde495b9491f76457c9"
+    },
+    {
+      "name": "model-00011-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "3c63baaed16d833432a919647af53ac76bb6b007",
+      "sha256": "5f3ae1b948aeee39da77aec558e8236cd65fe4d7cb7686a76bb007acc563c6d8"
+    },
+    {
+      "name": "model-00012-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "8568b440a4666ed1b4cda0b5d21496378304f326",
+      "sha256": "a3de1c7114677a8f5ac5c4892c90e8238ea5c1e2038c80e757dfc87c3902ca55"
+    },
+    {
+      "name": "model-00013-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "724083995a2257194321a3d00b36fd7d4bb7348d",
+      "sha256": "06ab79a41f74c9c5cb734816feb0c7fc364104b227165ee7391231e1155aa02a"
+    },
+    {
+      "name": "model-00014-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "a60b80b6510d7938d951fbddc76aaadd121c6268",
+      "sha256": "4138ed94603065ba884bbcadedb04d7718bb40117e85e6f5c6fc5b9c05b7a85b"
+    },
+    {
+      "name": "model-00015-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "7d4c34f3d716e1a47acff2f576b65b41a3ec4f3f",
+      "sha256": "69224e27b9de4e7dbf6fc936c6eaae08447bda3b80a6c31a871ab451173afd22"
+    },
+    {
+      "name": "model-00016-of-00018.safetensors",
+      "size": 3979564040,
+      "blob_id": "c67e3e42c9715298fa7f68c6b378bfb1d74290d0",
+      "sha256": "73cb9a1089fb6155cb648609478d6633be8a5c7d9ca5a05bc8925ce8a553cefe"
+    },
+    {
+      "name": "model-00017-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "23dd899179729a4370c655e2c2241cfdbe4ef4ba",
+      "sha256": "beb51f01056142ac4984bd800507b0dd0fd18de57f8e9ef6ea41d1a3598983a8"
+    },
+    {
+      "name": "model-00018-of-00018.safetensors",
+      "size": 3392197344,
+      "blob_id": "a92b4073fc6a58ffc9334ac63360fc8d9cc50d33",
+      "sha256": "1d3479509e21494658f9b64d317f5ea8e55c4025d28c702d6c4d0b356ce8ea06"
+    },
+    {
+      "name": "model.safetensors.index.json",
+      "size": 112216,
+      "blob_id": "da35e3c564457dface7d138f0b6cac284ff8958c",
+      "sha256": null
+    },
+    {
+      "name": "preprocessor_config.json",
+      "size": 390,
+      "blob_id": "2ea84a437d448ff71b08df68fdd949d5cc4ebb64",
+      "sha256": null
+    },
+    {
+      "name": "tokenizer.json",
+      "size": 12809320,
+      "blob_id": "9328ce9c41e80f6dd7bc2c66d8ae1fc93bf87440",
+      "sha256": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3"
+    },
+    {
+      "name": "tokenizer_config.json",
+      "size": 17928,
+      "blob_id": "5de744b3fca2129d7186979ae47c06be33903243",
+      "sha256": null
+    },
+    {
+      "name": "video_preprocessor_config.json",
+      "size": 385,
+      "blob_id": "3ba673a5ad7d4d13f54155ecd38b2a94a6dac8fe",
+      "sha256": null
+    },
+    {
+      "name": "vocab.json",
+      "size": 6722759,
+      "blob_id": "0aa0ce0658d60ac4a5d609f4eadb0e8e43514176",
+      "sha256": null
+    }
+  ]
+}

mlx/bf16/binding.json

@@ -0,0 +1,141 @@
+{
+  "adapter_dtype": "float32",
+  "adapter_placement": "question",
+  "adapter_scale": 2.0,
+  "base_hashes": {
+    ".gitattributes": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930",
+    "LICENSE": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+    "README.md": "57e4bdb258ee1a7d2635c5174ebd4e56abe392505cdb5f8bbb356b0dc4293641",
+    "chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041",
+    "config.json": "191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab",
+    "crc32.txt": "b42dd291f5f98b05807e458f5b47849969a9b3326acbf0c97d28b05826740b83",
+    "generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+    "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "model-00001-of-00018.safetensors": "ba0ce20aae489ad196733da5064bcdf159a1fe84f53336648196e1ebb7751b1c",
+    "model-00002-of-00018.safetensors": "06a148c01bfbe3faa14a5f184a7ff29a706f7ae1c8b2705d2058e26d17a001fb",
+    "model-00003-of-00018.safetensors": "2e1bf62cbcd406eaa64b60d10353e1f0ef4039d0976e56f05cabe953454f9968",
+    "model-00004-of-00018.safetensors": "511e34063187882659753c4d93f3859f93c019fd438d8813071921c81d9a3f1a",
+    "model-00005-of-00018.safetensors": "635cb53446dc74f219740fc59e18b774f877b803b9722e289ca62575a6efa701",
+    "model-00006-of-00018.safetensors": "0bc5214fac607f0e6cc92eec3789d4b8559410ef9fce66621ba8158e8410dae0",
+    "model-00007-of-00018.safetensors": "80b0c49033e9a0d5762562aa12f4acdb7f54da586f3d0110f28c48d91cf07892",
+    "model-00008-of-00018.safetensors": "7192c5b66185d3592927daabee1cc19e6f6e0ce75988ee20e824b624765fda79",
+    "model-00009-of-00018.safetensors": "af3c48cc37af44f3db6ae0579baf019180d48d9c527caa0a1f03ff85813a56d8",
+    "model-00010-of-00018.safetensors": "163490a76f3bea3a40855b7efc04ce6d27afaf1a34f0bbde495b9491f76457c9",
+    "model-00011-of-00018.safetensors": "5f3ae1b948aeee39da77aec558e8236cd65fe4d7cb7686a76bb007acc563c6d8",
+    "model-00012-of-00018.safetensors": "a3de1c7114677a8f5ac5c4892c90e8238ea5c1e2038c80e757dfc87c3902ca55",
+    "model-00013-of-00018.safetensors": "06ab79a41f74c9c5cb734816feb0c7fc364104b227165ee7391231e1155aa02a",
+    "model-00014-of-00018.safetensors": "4138ed94603065ba884bbcadedb04d7718bb40117e85e6f5c6fc5b9c05b7a85b",
+    "model-00015-of-00018.safetensors": "69224e27b9de4e7dbf6fc936c6eaae08447bda3b80a6c31a871ab451173afd22",
+    "model-00016-of-00018.safetensors": "73cb9a1089fb6155cb648609478d6633be8a5c7d9ca5a05bc8925ce8a553cefe",
+    "model-00017-of-00018.safetensors": "beb51f01056142ac4984bd800507b0dd0fd18de57f8e9ef6ea41d1a3598983a8",
+    "model-00018-of-00018.safetensors": "1d3479509e21494658f9b64d317f5ea8e55c4025d28c702d6c4d0b356ce8ea06",
+    "model.safetensors.index.json": "77042094076611b69791a610065f28b7013b8c621795fa86ddccc8bac7d1b9df",
+    "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+    "tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+    "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003"
+  },
+  "base_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+  "conversion": "upstream Qwen3.5 sanitization, norms promoted before unit offset",
+  "dependencies": {
+    "mlx": "0.32.2",
+    "mlx-vlm": "0.7.1",
+    "numpy": "2.5.3",
+    "transformers": "5.17.0"
+  },
+  "dtype": "bfloat16",
+  "files": {
+    "LICENSE": "a61385b8bc4e786195136404b4975fede3c0bca526877f526482e9af93d47457",
+    "MODIFICATIONS.md": "218218b43b27132a6cfa032d2be908decd0966f5b655946a8668506731c77de7",
+    "NOTICE": "ccf2b8e98f0606945a5fcf9f6522c1f2c01b279d55dc21ee02c5a4acadf8e8d1",
+    "adapter.safetensors": "2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca",
+    "backbone/.gitattributes": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930",
+    "backbone/LICENSE": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+    "backbone/README.md": "57e4bdb258ee1a7d2635c5174ebd4e56abe392505cdb5f8bbb356b0dc4293641",
+    "backbone/chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041",
+    "backbone/config.json": "191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab",
+    "backbone/crc32.txt": "b42dd291f5f98b05807e458f5b47849969a9b3326acbf0c97d28b05826740b83",
+    "backbone/generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+    "backbone/merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "backbone/model-00001-of-00018.safetensors": "6c54d794f08d8a479e8a123b6ab3473b8a8f304f0da59b043aabe7bdb5f05a7a",
+    "backbone/model-00002-of-00018.safetensors": "3de19e7456388362e7dbe1455362f6b2661d8d7084a7a346e7d3f77053ff0f78",
+    "backbone/model-00003-of-00018.safetensors": "103e7f75798c312e696d2547889732b110a634725f6233b7b0bc654bf3365528",
+    "backbone/model-00004-of-00018.safetensors": "9b6ff88af2b387c943366b263d1ebef06090cf2a94e637895a74eb10300bf5da",
+    "backbone/model-00005-of-00018.safetensors": "f2e95aa5371257fadde49c6d735b716aab00868ae689befd54c091df7a6c57b4",
+    "backbone/model-00006-of-00018.safetensors": "7c196564fbb98f683573ae02d3a90bd74ccb7289d9103f09c76d9feffcc64b24",
+    "backbone/model-00007-of-00018.safetensors": "1a657de97643d5283547047925453e0bbec151b5f293f0a48ee8fbffb82c83cb",
+    "backbone/model-00008-of-00018.safetensors": "e26030a4ee68739f4092696d685b9ef5b4a7052f4843e949cf4419ee7d086b81",
+    "backbone/model-00009-of-00018.safetensors": "d73885d7e8995d58cd722b6fd4976035f30e3464189a71d88bb8e504a4612c53",
+    "backbone/model-00010-of-00018.safetensors": "ee367c91f6faf3a2d5245e28ee20dbe4e51a1ab08f8e27029c67e7c47a77bd89",
+    "backbone/model-00011-of-00018.safetensors": "01ea6406c8ee3f3bd0cbe96fb1ff120bdafc20bdeb4eb5dc8fc08894fef9221f",
+    "backbone/model-00012-of-00018.safetensors": "59da9b95e4d818c1189f681044df6bb9a5c7375ea0a01b8d6a6a682451fc4a8e",
+    "backbone/model-00013-of-00018.safetensors": "c2f63ec1a168d0f328da8ef74caee72d4e67d6dccfd9ccb595abcaedaeae86c4",
+    "backbone/model-00014-of-00018.safetensors": "d8a6453ec4fbe9763644dd9127c3a5ad5fec5c8a5cde6f1414f1101ee9a1250c",
+    "backbone/model-00015-of-00018.safetensors": "95db368ab83b8f60d1b9205de6ffa97adbe665d7e61e9adcfb237d25dabf9f8a",
+    "backbone/model-00016-of-00018.safetensors": "482d3d948c8cb31068323a85b7c2d445271a28a08699bbed48c13e465894715a",
+    "backbone/model-00017-of-00018.safetensors": "7615db84bee928608723f0e5e887f98e11091ccd86583453efcf9745050741f2",
+    "backbone/model-00018-of-00018.safetensors": "1219c9ea7951f2bb93c0ccafa2e6e65ac9111fda00961e3fbe614e30050c95e9",
+    "backbone/model.safetensors.index.json": "5aec933c5ef08d6c1d411b1b1f225b97d7c55f8eeed4b74535849ce9361e595f",
+    "backbone/preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "backbone/tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+    "backbone/tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+    "backbone/video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "backbone/vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+    "heads.npz": "126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f"
+  },
+  "head_dtype": "float32",
+  "profile": "quality",
+  "quantization": null,
+  "recurrent_state_dtype": "float32",
+  "schema": "solomon-mlx-binding-v1",
+  "sensitive_parameters": "FP32 normalization weights, A_log and dt_bias",
+  "solomon_revision": "2ec506902269e4636285c8811f6c0f52c9300c0c",
+  "source_hashes": {
+    ".gitattributes": "8baff4be52225e26dd13dffb05fed3d0db821911c36d7ffd6f6d00d02ca421c7",
+    "LICENSE": "a61385b8bc4e786195136404b4975fede3c0bca526877f526482e9af93d47457",
+    "MANIFEST.json": "a473433af0c2de6a97a0d99e9e47216e91ed67c4269e07ca8d678d8c068c317b",
+    "MODIFICATIONS.md": "218218b43b27132a6cfa032d2be908decd0966f5b655946a8668506731c77de7",
+    "NOTICE": "ccf2b8e98f0606945a5fcf9f6522c1f2c01b279d55dc21ee02c5a4acadf8e8d1",
+    "PUSH.md": "cc8e0ea0a0dec3db020f8245eb90b04571b77d8ac9f3efcd64d0ab0bef5bac16",
+    "README.md": "51a2389ef504652f0b0a292cfaf28bb5e7635bde1aede0289f42696ad5818afc",
+    "adapter/adapter.safetensors": "2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca",
+    "adapter/config.json": "cafc99ce8299eeca3fc2b2e1a2b08dcf659b66467d6675b6f8731a616693dbc4",
+    "adapter/heads.npz": "126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f",
+    "licenses/Qwen-Apache-2.0.txt": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+    "requirements.lock": "27675e999e5bcfc175ed768711856a975c2286d2ba807471cc7b0213d6d13f89",
+    "serving/scope9-readout-temperature-v2.json": "baa7263ca9e865dda230617563e6a615de5050adc620c28924dffef68d527118",
+    "serving/selection.json": "14fa9c88a913d61a60d13b65f0974cff3985f40d50f204a1b83a9426db21b362",
+    "serving/service-export.json": "ccd7c0ca37cd900912631ab98b72703a4a4aebf2fadd6208675781aabd1e5ac8",
+    "serving/serving-binding.json": "1849df4bd4897d048a45a2f4cbc63beac4ded6afc0d43ff41e53a8a6dc8c49e4",
+    "src/scope35/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "src/scope35/engine.py": "61f91be0dabc680795e5d4b83f9d80f02cbed2502b06e3809fdc09fbeeb99202",
+    "src/scope4/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "src/scope4/cuda_engine.py": "f41dd19a248193bbda6aa81705317c702e0ec07976c7520a513b14260edddbf2",
+    "src/scope4/cuda_engine_v2.py": "d536117abd403811bba62129c2ba30d2e890c9058741baff65f3e7414f829bce",
+    "src/scope4/cuda_service.py": "c1c2267401b88dc5d4ad3d18b08c547c9b2e5d0a01c922d8ba88a1756075315a",
+    "src/scope4/engine.py": "b1ef3525011a8ec66c308f461e525d73a0a2b927bbfa605c76bef960d25fb5ff",
+    "src/scope4/readout.py": "cafcadbfc6ab3e77eac7bcd092d2254049c987913e2f744318ae7e2f36c24587",
+    "src/scope4/service.py": "2dfbfbadf92bce3f001063f9d94e5bf19a8d0ff9d143dd68b20d5032dd2e5e73",
+    "src/scope5/__init__.py": "6c079cc4864d55e798e243a6cbdc6e2b3fd963ff31fd28cf9a8122819a8c65cf",
+    "src/scope5/cuda_engine.py": "2d7d64d7e01cccefdb7afd504b80c54443ca271d0bcd3cf352b6bfd99dc491e3",
+    "src/scope5/heads_runtime.py": "48c0c29c79a8b781cddf22034b9ffee3df9a8d61b8709b1dd808b8df47024fe7",
+    "src/scope5/heads_service.py": "5c775e26bcb2de1c32156ce0cc404d06de8fbedff6c67fcb5606ce3713b88342",
+    "src/scope5/routing.py": "0d88a7f0433dd448b81bd04c48044c98e453038d9ffcd903c9479c20ec6651c1",
+    "src/scope5/service.py": "d056ae3e4ebda5d89ba4ebe0c93ae225a31e33a8f543632a0976703c25501019",
+    "src/scope6/__init__.py": "e72ad8e334509eb002496207c4e43598d222ba2953162344e43ee122e3832df0",
+    "src/scope6/evidence.py": "a0ece458b5c0546c1f80b48cea87ebc1c3732e83f2c0f8e58969645bc8bde2f7",
+    "src/scope6/evidence_v3.py": "9b2b9e9c319242ca9c4a96a2567d1c1adb3134332c95dd6dfd60114c54d09426",
+    "src/scope6/retrieval.py": "4e5094aacc2ee3bbb0663de402198cd418933c4682f9d5a9006d4058e15f9b4f",
+    "src/scope6/runtime.py": "2d154d8ba39e61a10b23bba286e1ce87f57dbdc21d8f6e73430c0929a1990fe7",
+    "src/scope6/service.py": "5e7b6f9e163be35ab17ed76355ecee9faa541f27ca76e969ff49f2076dfbd9b8",
+    "src/scope6/service_v3.py": "b92cfdee8ca1c039645a97746e47fc99965f9c5f5ecd98e31aedf71bca29b611",
+    "src/scope6/serving.py": "aab481eb4b1d34c13caaf8c3628f3702f2956bb413f288c7a30979d5c2281356",
+    "src/scope9/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "src/scope9/api.py": "db677e569a3f7d15e6398d4bfb9ac0b00f286502fe4d97e9811388ccfb95dcae",
+    "src/scope9/live.py": "62f40568c8c0bc7ea4d436325eb54d49fe06ea8f51c304b384dcffb605bf3e3f",
+    "src/scope9/prompts.py": "53e22b99c19f5af588fea2167594c6331877a8ce71d0a0424bce10000bc22b53",
+    "src/scope9/semantics.py": "9fd9041c50f8925608bf6a2f351abab745648137400475bdf46f66885bef67dc",
+    "src/scope9/service.py": "9deed4e6acae4b26619a95f6f2ef19ced6bb42d6d6a4e1710c26accff4bc198b"
+  }
+}

mlx/bf16/conversion.json

@@ -0,0 +1,203 @@
+{
+  "run_id": "bf16-cpu-79517a5cd7aa",
+  "base_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+  "solomon_revision": "2ec506902269e4636285c8811f6c0f52c9300c0c",
+  "backend": "mlx-linux-cpu",
+  "binding_sha256": "6d45715aa040fad98b061ff2cbafb35b047143ef2475646cee3df7a334f4d530",
+  "converter_code_sha256": "648e440cface0838f2dcc8d89b3ab172d97f4ffc1f88fe0b7cbbe3ca73b8a575",
+  "total_output_bytes": 55610774146,
+  "seconds": 220.91851106299998,
+  "apple_silicon_validation": "pending; conversion is not inference qualification",
+  "files": [
+    {
+      "name": "LICENSE",
+      "size": 11344,
+      "sha256": "a61385b8bc4e786195136404b4975fede3c0bca526877f526482e9af93d47457"
+    },
+    {
+      "name": "MODIFICATIONS.md",
+      "size": 4197,
+      "sha256": "218218b43b27132a6cfa032d2be908decd0966f5b655946a8668506731c77de7"
+    },
+    {
+      "name": "NOTICE",
+      "size": 3891,
+      "sha256": "ccf2b8e98f0606945a5fcf9f6522c1f2c01b279d55dc21ee02c5a4acadf8e8d1"
+    },
+    {
+      "name": "adapter.safetensors",
+      "size": 870363376,
+      "sha256": "2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca"
+    },
+    {
+      "name": "backbone/.gitattributes",
+      "size": 1570,
+      "sha256": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930"
+    },
+    {
+      "name": "backbone/LICENSE",
+      "size": 11544,
+      "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a"
+    },
+    {
+      "name": "backbone/README.md",
+      "size": 65012,
+      "sha256": "57e4bdb258ee1a7d2635c5174ebd4e56abe392505cdb5f8bbb356b0dc4293641"
+    },
+    {
+      "name": "backbone/chat_template.jinja",
+      "size": 8952,
+      "sha256": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041"
+    },
+    {
+      "name": "backbone/config.json",
+      "size": 4312,
+      "sha256": "191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab"
+    },
+    {
+      "name": "backbone/crc32.txt",
+      "size": 238,
+      "sha256": "b42dd291f5f98b05807e458f5b47849969a9b3326acbf0c97d28b05826740b83"
+    },
+    {
+      "name": "backbone/generation_config.json",
+      "size": 202,
+      "sha256": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e"
+    },
+    {
+      "name": "backbone/merges.txt",
+      "size": 3353259,
+      "sha256": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d"
+    },
+    {
+      "name": "backbone/model-00001-of-00018.safetensors",
+      "size": 3967078356,
+      "sha256": "6c54d794f08d8a479e8a123b6ab3473b8a8f304f0da59b043aabe7bdb5f05a7a"
+    },
+    {
+      "name": "backbone/model-00002-of-00018.safetensors",
+      "size": 3043154160,
+      "sha256": "3de19e7456388362e7dbe1455362f6b2661d8d7084a7a346e7d3f77053ff0f78"
+    },
+    {
+      "name": "backbone/model-00003-of-00018.safetensors",
+      "size": 2542796953,
+      "sha256": "103e7f75798c312e696d2547889732b110a634725f6233b7b0bc654bf3365528"
+    },
+    {
+      "name": "backbone/model-00004-of-00018.safetensors",
+      "size": 3989088609,
+      "sha256": "9b6ff88af2b387c943366b263d1ebef06090cf2a94e637895a74eb10300bf5da"
+    },
+    {
+      "name": "backbone/model-00005-of-00018.safetensors",
+      "size": 2099392965,
+      "sha256": "f2e95aa5371257fadde49c6d735b716aab00868ae689befd54c091df7a6c57b4"
+    },
+    {
+      "name": "backbone/model-00006-of-00018.safetensors",
+      "size": 3979669611,
+      "sha256": "7c196564fbb98f683573ae02d3a90bd74ccb7289d9103f09c76d9feffcc64b24"
+    },
+    {
+      "name": "backbone/model-00007-of-00018.safetensors",
+      "size": 2108811989,
+      "sha256": "1a657de97643d5283547047925453e0bbec151b5f293f0a48ee8fbffb82c83cb"
+    },
+    {
+      "name": "backbone/model-00008-of-00018.safetensors",
+      "size": 3979669575,
+      "sha256": "e26030a4ee68739f4092696d685b9ef5b4a7052f4843e949cf4419ee7d086b81"
+    },
+    {
+      "name": "backbone/model-00009-of-00018.safetensors",
+      "size": 2108812007,
+      "sha256": "d73885d7e8995d58cd722b6fd4976035f30e3464189a71d88bb8e504a4612c53"
+    },
+    {
+      "name": "backbone/model-00010-of-00018.safetensors",
+      "size": 3979669601,
+      "sha256": "ee367c91f6faf3a2d5245e28ee20dbe4e51a1ab08f8e27029c67e7c47a77bd89"
+    },
+    {
+      "name": "backbone/model-00011-of-00018.safetensors",
+      "size": 2108812003,
+      "sha256": "01ea6406c8ee3f3bd0cbe96fb1ff120bdafc20bdeb4eb5dc8fc08894fef9221f"
+    },
+    {
+      "name": "backbone/model-00012-of-00018.safetensors",
+      "size": 3979669597,
+      "sha256": "59da9b95e4d818c1189f681044df6bb9a5c7375ea0a01b8d6a6a682451fc4a8e"
+    },
+    {
+      "name": "backbone/model-00013-of-00018.safetensors",
+      "size": 2108811987,
+      "sha256": "c2f63ec1a168d0f328da8ef74caee72d4e67d6dccfd9ccb595abcaedaeae86c4"
+    },
+    {
+      "name": "backbone/model-00014-of-00018.safetensors",
+      "size": 3979669605,
+      "sha256": "d8a6453ec4fbe9763644dd9127c3a5ad5fec5c8a5cde6f1414f1101ee9a1250c"
+    },
+    {
+      "name": "backbone/model-00015-of-00018.safetensors",
+      "size": 2108812005,
+      "sha256": "95db368ab83b8f60d1b9205de6ffa97adbe665d7e61e9adcfb237d25dabf9f8a"
+    },
+    {
+      "name": "backbone/model-00016-of-00018.safetensors",
+      "size": 3979690166,
+      "sha256": "482d3d948c8cb31068323a85b7c2d445271a28a08699bbed48c13e465894715a"
+    },
+    {
+      "name": "backbone/model-00017-of-00018.safetensors",
+      "size": 2108812005,
+      "sha256": "7615db84bee928608723f0e5e887f98e11091ccd86583453efcf9745050741f2"
+    },
+    {
+      "name": "backbone/model-00018-of-00018.safetensors",
+      "size": 2542796942,
+      "sha256": "1219c9ea7951f2bb93c0ccafa2e6e65ac9111fda00961e3fbe614e30050c95e9"
+    },
+    {
+      "name": "backbone/model.safetensors.index.json",
+      "size": 111087,
+      "sha256": "5aec933c5ef08d6c1d411b1b1f225b97d7c55f8eeed4b74535849ce9361e595f"
+    },
+    {
+      "name": "backbone/preprocessor_config.json",
+      "size": 390,
+      "sha256": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516"
+    },
+    {
+      "name": "backbone/tokenizer.json",
+      "size": 12809320,
+      "sha256": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3"
+    },
+    {
+      "name": "backbone/tokenizer_config.json",
+      "size": 17928,
+      "sha256": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27"
+    },
+    {
+      "name": "backbone/video_preprocessor_config.json",
+      "size": 385,
+      "sha256": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13"
+    },
+    {
+      "name": "backbone/vocab.json",
+      "size": 6722759,
+      "sha256": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003"
+    },
+    {
+      "name": "heads.npz",
+      "size": 2053938,
+      "sha256": "126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f"
+    },
+    {
+      "name": "binding.json",
+      "size": 12306,
+      "sha256": "6d45715aa040fad98b061ff2cbafb35b047143ef2475646cee3df7a334f4d530"
+    }
+  ]
+}

mlx/docs/UPSTREAM-MODIFICATIONS.md

@@ -0,0 +1,75 @@
+# Statement of changes
+
+Apache License 2.0, section 4(b): prominent notice that files carry modifications.
+
+## What is modified
+
+**No upstream source file is modified.** No file from `Qwen/Qwen3.8-27B` is edited,
+renamed, patched or redistributed in this repository, with one exception: the
+upstream licence text is reproduced byte-for-byte at `licenses/Qwen-Apache-2.0.txt`
+(sha256 `bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a`) because section 4(a) requires it. That file is
+unmodified and carries the upstream copyright.
+
+The modification this work carries is not an edit to a source file. It is a set
+of **trained parameters applied to the base model at inference time**, plus an
+original serving layer that reads the model's logits. Concretely:
+
+| Change | Artifact | sha256 |
+|---|---|---|
+| LoRA adapter, rank 64, question-side placement, float32 | `adapter/adapter.safetensors` | `2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca` |
+| Trained linear answer heads | `adapter/heads.npz` | `126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f` |
+| Readout calibration, one positive scalar per task | `serving/scope9-readout-temperature-v2.json` | file `baa7263ca9e865dda230617563e6a615de5050adc620c28924dffef68d527118` / payload `682d611ec53c3322905c7e265bf9b9b35a1cd581f6d8b7ea924df864a3d74278` |
+| Runtime identity binding | `serving/serving-binding.json` | payload `95683c1f87ec3f71b7657669dc311918ff53b7d41a981eaa8d827047e72cb505` |
+| Serving layer (original work, not derived from upstream code) | `src/` | see `MANIFEST.json` |
+
+Base model, unmodified and not redistributed: `Qwen/Qwen3.8-27B` at revision
+`1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0`, Copyright 2026 Alibaba Cloud, Apache-2.0.
+
+Training took place between 16 and 20 September 2026. The shipped artifacts are
+identified by the checksums in the table above and in `MANIFEST.json`.
+
+## Which files carry a change notice
+
+| File | Why |
+|---|---|
+| `NOTICE` | Section 4(b) and 4(c) statement, carried with every copy |
+| `MODIFICATIONS.md` | this file |
+| `README.md` | names the base model, the pinned revision and the derivative relationship in the front matter and in the body |
+| `adapter/config.json` | machine-readable record of the base repo, the pinned revision and both weight checksums |
+| `serving/serving-binding.json` | pins the exact runtime the weights were measured on and refuses to load against a different one |
+
+No file under `src/` carries an upstream change notice, because no file under
+`src/` contains upstream code. Every file there is original work, written for
+this project, and is covered by the repository's own Apache-2.0 `LICENSE` and by
+the copyright line in `NOTICE`.
+
+All of the changes described above — the adapter, the heads, the calibration, the
+serving binding and the serving layer — are Copyright 2026
+Doccy Pty Ltd and licensed under Apache-2.0.
+
+## Third-party text scan
+
+Before release, **every file staged into this repository was scanned for text
+originating in third-party source documents.** The scan compared normalised
+6-gram and 8-gram shingles of every staged text file against:
+
+1. the 42 third-party source records the training and evaluation panels were
+   built from (Apache-2.0, MIT, BSD-3-Clause, CC BY 4.0, CC BY-SA 4.0, CC0,
+   OGL v3.0 and US-government public-domain assertions); and
+2. every generated panel and document corpus on disk.
+
+**Result: no third-party document text is present in any shipped file.** The
+only matches were:
+
+* the reproduced Apache-2.0 licence text at `licenses/Qwen-Apache-2.0.txt`, which
+  matches an Apache-2.0 licence document held in the evaluation corpus and is
+  required to be here verbatim; and
+* the phrase *"A missing fact is not a negative fact"*, which is **our own
+  prompt-template wording** appearing in our own evaluation panels, not
+  third-party text entering our prompts.
+
+Acceptance fixtures are excluded from this repository entirely. The fixture
+documents used in live acceptance are original synthetic text authored for this
+project and held in tooling that is not distributed.
+
+Re-run the scan with `ops/solomon_package.py --scan` in the source project.

mlx/docs/VALIDATION-20260921.md

@@ -0,0 +1,46 @@
+# Solomon BF16 CUDA parity validation — 21 September 2026
+
+Full BF16 inference was exercised on the Apple M5 Max / 128 GB Mac. No weights or temperatures were changed. New temperature fitting is out of scope.
+
+## Confirmed results
+
+| Check | Result |
+|---|---|
+| Fresh text fixtures, all five answer types | 22/22 decisions match CUDA |
+| Fresh page-image fixtures | 4/4 decisions match CUDA |
+| Saved text subset | 645/645 branch decisions and 327/327 whole-question decisions match CUDA |
+| Prefix tokens and captured full token sequences | Exact match with CUDA |
+| Replay and fresh process versus previous run | Zero logit drift on this Mac |
+| Public API cache isolation, evidence and invalid-input checks | Passed |
+| Existing package tests | 21 passed |
+| Parity workflow and reserved-answer regression tests | 2 passed |
+| Lint | Passed |
+
+The saved subset covers 196 documents and all five tasks. It comes from previously scored calibration-fit inputs and is a diagnostic subset, not a complete held-out qualification. It was used only for comparison; nothing was fitted.
+
+## Numerical differences
+
+With the same frozen CUDA serving temperatures applied once on both backends, maximum probability drift on the saved subset is 2.5871 percentage points; mean drift is 0.0126 points. At identical T=1, maximum drift is 4.1508 points and mean drift is 0.0078 points. All compared decisions still agree.
+
+CUDA and MLX logits are not bitwise equal. The report preserves the largest probability differences for inspection. No claim is made that the CUDA confidence calibration has been independently validated for MLX.
+
+The focused runs used 59.90 GB peak Metal allocation. This is not a measurement of the maximum supported context or many-page memory use.
+
+## Remaining work
+
+The untouched certification panel is now scored directly: 1,200 documents / 21,718 branches. It skips fit/development scoring and temperature fitting. The complete agreement gate is at least 99.9% for both branches and whole questions, at T=1 and at the frozen CUDA temperatures. Probability drift and task accuracy are reported separately.
+
+Image fixtures and API evidence checks are limited tests; broad image accuracy and CUDA evidence-selection equivalence are not established by them.
+
+Runtime fingerprint: `33c9b63f036c5c039a2db4ba944f5b0042ae8b8e485e68c2aeddb57c407f8908`.
+
+Detailed evaluation inputs and outputs remain private; the source release includes aggregate results only.
+
+## Adapter-only packaging checks
+
+The 21 September source update passed 24 portable package tests, including seven
+Hub-loader tests. The local development suite passed 30 tests. The new verifier
+also checked all 37 files of the existing full BF16 conversion. The built wheel
+contains the original converter with its exact recorded source hash and both
+pinned-input manifests. These checks cover packaging and integrity, not additional
+trained-model parity.

mlx/examples/decide.py

@@ -0,0 +1,21 @@
+from solomon_mlx import Solomon
+
+model = Solomon.load("models/quality")
+questions = {
+    "certified": {"type": "noul", "instructions": "Is Rookwood Ltd certified?"},
+    "auditor": {
+        "type": "choice",
+        "instructions": "Who performs the audit?",
+        "options": ["The Buyer", "The grower", "An independent auditor"],
+    },
+    "severity": {
+        "type": "score",
+        "instructions": "What is the breach severity?",
+        "levels": ["none recorded", "minor", "material"],
+    },
+}
+with model.prefill(
+    "Rookwood Ltd is certified. An independent auditor performs the audit. One minor breach is recorded."
+) as state:
+    print(model.decide(state=state, questions=questions, evidence="support"))
+    state.save("document-replay.json")

mlx/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling==1.32.3"]
+build-backend = "hatchling.build"
+
+[project]
+name = "solomon-mlx"
+version = "0.1.0"
+description = "Solomon v1.1 BF16 inference on Apple Silicon"
+license = "Apache-2.0"
+license-files = ["LICENSE", "NOTICE", "MODIFICATIONS.md", "docs/UPSTREAM-MODIFICATIONS.md"]
+requires-python = ">=3.12,<3.14"
+dependencies = ["mlx==0.32.2", "mlx-vlm==0.7.1", "transformers==5.17.0", "numpy==2.5.3", "pillow==12.3.0", "safetensors==0.8.0", "huggingface-hub==1.32.0", "scipy==1.18.1"]
+
+[project.optional-dependencies]
+dev = ["pytest==9.1.1", "ruff==0.16.8", "modal==1.5.5"]
+cloud = [
+    "boto3==1.43.98",
+    "mlx[cpu]==0.32.2; sys_platform == 'linux'",
+    "modal==1.5.5",
+]
+
+[project.scripts]
+solomon-mlx = "solomon_mlx.cli:main"
+solomon-mlx-hub = "solomon_mlx_hub.__main__:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = ["model: requires the full pinned model"]
+
+[tool.ruff]
+line-length = 110
+extend-exclude = ["src/solomon_mlx/_vendor", "snapshots", "models", "evaluations"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/solomon_mlx", "src/solomon_mlx_hub"]

mlx/requirements.cloud.lock

@@ -0,0 +1,1072 @@
+# This file was autogenerated by uv via the following command:
+#    uv export --frozen --no-dev --extra cloud --no-emit-project --format requirements-txt --output-file requirements.cloud.lock
+aiohappyeyeballs==2.7.1 \
+    --hash=sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d \
+    --hash=sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472
+    # via aiohttp
+aiohttp==3.14.3 \
+    --hash=sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043 \
+    --hash=sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b \
+    --hash=sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf \
+    --hash=sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559 \
+    --hash=sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86 \
+    --hash=sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a \
+    --hash=sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c \
+    --hash=sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5 \
+    --hash=sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d \
+    --hash=sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71 \
+    --hash=sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1 \
+    --hash=sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427 \
+    --hash=sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42 \
+    --hash=sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd \
+    --hash=sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8 \
+    --hash=sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228 \
+    --hash=sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0 \
+    --hash=sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee \
+    --hash=sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f \
+    --hash=sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c \
+    --hash=sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371 \
+    --hash=sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0 \
+    --hash=sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529 \
+    --hash=sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc \
+    --hash=sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b \
+    --hash=sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80 \
+    --hash=sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e \
+    --hash=sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807 \
+    --hash=sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d \
+    --hash=sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82 \
+    --hash=sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19 \
+    --hash=sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0 \
+    --hash=sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5 \
+    --hash=sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4 \
+    --hash=sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2 \
+    --hash=sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9 \
+    --hash=sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883 \
+    --hash=sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde \
+    --hash=sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787 \
+    --hash=sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627 \
+    --hash=sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a \
+    --hash=sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24
+    # via modal
+aiosignal==1.4.0 \
+    --hash=sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e \
+    --hash=sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7
+    # via aiohttp
+annotated-doc==0.0.5 \
+    --hash=sha256:117bac03a25ede5df5440e855b32d556049ca169ead221505badf432fed4b101 \
+    --hash=sha256:c7e58ce09192557605d8bbd92836d7e1d520ac9580096042c0bfd197efacf1bb
+    # via
+    #   fastapi
+    #   typer
+annotated-types==0.8.0 \
+    --hash=sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7 \
+    --hash=sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0
+    # via pydantic
+anyio==4.15.1 \
+    --hash=sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101 \
+    --hash=sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94
+    # via
+    #   httpx
+    #   starlette
+    #   watchfiles
+attrs==26.1.0 \
+    --hash=sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309 \
+    --hash=sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32
+    # via aiohttp
+boto3==1.43.98 \
+    --hash=sha256:1ec732e023fb29c12dc8520f925b5bbbed29eeb36b5764b5a5c26052d7c721f7 \
+    --hash=sha256:7454f666a9e852a56db0a7fa23be33a899f64e27828930eac43c3edba7b34e17
+    # via solomon-mlx
+botocore==1.43.98 \
+    --hash=sha256:6135dd639ea6d1b3b49381bc253c8a139d61f7d44cb5f7dae8e7cd1791758572 \
+    --hash=sha256:84b35b10402c2fc0c265f634fbf86336eecc6489ee23f55074b329924b2cfd6f
+    # via
+    #   boto3
+    #   s3transfer
+cbor2==6.1.4 \
+    --hash=sha256:01ecc79a28f33d17331943ce508fc1e21f4b06553c73f874f4c77120d72b2ef9 \
+    --hash=sha256:1fc15061553e4494dc10883237501e3402c645fe509248dd698e1faf2460d68b \
+    --hash=sha256:2310f07db3f9ba26f2a623774ff9f3dc7185af54f732ea119785a6b1bf7e1e7e \
+    --hash=sha256:310f3dfb296ba48fe9b63c5cf26e691e3548a1eae6901d2f0c18e941d151f220 \
+    --hash=sha256:32a4663425fbca4a4a7aa918eb5789d844c406439e58424cf34511f79f559242 \
+    --hash=sha256:36ae16d64b1f7b620c1af748e7b6947e20069ef80eee56871c5fbb84cc635905 \
+    --hash=sha256:4bd29f21529e279d50fc14f1a811f7b05b4d8e66a7969163cce98983b6817245 \
+    --hash=sha256:553a46bda7d09552631a714e22b91e6ff2c867ecd91511596ce290d8879b8d5b \
+    --hash=sha256:598710183daae69cbdeb177a870ec64aa601de8138a61491fd256826d15a860f \
+    --hash=sha256:5e6c76004d674ad1c620660cb0bc5a8a0b72a5d8c7b70926d8e09e6d7e87332f \
+    --hash=sha256:69978901302ecbc8cda57b520487c5c5240ed217de783eb7728fceb258311d76 \
+    --hash=sha256:ad4efa23fee6447e56a269191044e06eb39e809458bcd674e164fe9445feafd0 \
+    --hash=sha256:c08b9c7d2ea013e24a0cb819b872b0119dde404f64a1182c0b24095b7bba781f \
+    --hash=sha256:c48a7c938fc5fa5300ff82b5df09068dcb4838685ae8556b5ee8279d74f97ab4 \
+    --hash=sha256:cc8cd300e236e9797b2e1ce306109dc481fcccf78bfa2682bf36d99e6eab1ec6 \
+    --hash=sha256:d2560c2ba6a95904ba2a0ca257af878c4344409d9b46d8e646d8ebb617b1e0dd \
+    --hash=sha256:d9ada5a6ccfbb8ea7a3aa2aeb028421b52d8e0cd9323f0a2aeaa9c09d25fbce2
+    # via modal
+certifi==2026.7.22 \
+    --hash=sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775 \
+    --hash=sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55
+    # via
+    #   httpcore
+    #   httpx
+    #   modal
+    #   requests
+cffi==2.1.1 \
+    --hash=sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e \
+    --hash=sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971 \
+    --hash=sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d \
+    --hash=sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517 \
+    --hash=sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735 \
+    --hash=sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c \
+    --hash=sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e \
+    --hash=sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac \
+    --hash=sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50 \
+    --hash=sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973 \
+    --hash=sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890 \
+    --hash=sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c \
+    --hash=sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80 \
+    --hash=sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a \
+    --hash=sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6 \
+    --hash=sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b \
+    --hash=sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2 \
+    --hash=sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3 \
+    --hash=sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e \
+    --hash=sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf \
+    --hash=sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0 \
+    --hash=sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be \
+    --hash=sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7 \
+    --hash=sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125 \
+    --hash=sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a \
+    --hash=sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf \
+    --hash=sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264
+    # via
+    #   miniaudio
+    #   sounddevice
+charset-normalizer==3.5.1 \
+    --hash=sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac \
+    --hash=sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369 \
+    --hash=sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031 \
+    --hash=sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235 \
+    --hash=sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072 \
+    --hash=sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c \
+    --hash=sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950 \
+    --hash=sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2 \
+    --hash=sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e \
+    --hash=sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2 \
+    --hash=sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa \
+    --hash=sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2 \
+    --hash=sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71 \
+    --hash=sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96 \
+    --hash=sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8 \
+    --hash=sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9 \
+    --hash=sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f \
+    --hash=sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591 \
+    --hash=sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e \
+    --hash=sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3 \
+    --hash=sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3 \
+    --hash=sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6 \
+    --hash=sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959 \
+    --hash=sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf \
+    --hash=sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0 \
+    --hash=sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e \
+    --hash=sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491 \
+    --hash=sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a \
+    --hash=sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c \
+    --hash=sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7 \
+    --hash=sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a \
+    --hash=sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9 \
+    --hash=sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e \
+    --hash=sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4 \
+    --hash=sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3 \
+    --hash=sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99 \
+    --hash=sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6 \
+    --hash=sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598 \
+    --hash=sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6 \
+    --hash=sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962 \
+    --hash=sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08 \
+    --hash=sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573 \
+    --hash=sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6 \
+    --hash=sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2 \
+    --hash=sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2 \
+    --hash=sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe \
+    --hash=sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3 \
+    --hash=sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc \
+    --hash=sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d \
+    --hash=sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893 \
+    --hash=sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d \
+    --hash=sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada \
+    --hash=sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876 \
+    --hash=sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f \
+    --hash=sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0
+    # via requests
+click==8.5.0 \
+    --hash=sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360 \
+    --hash=sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34
+    # via
+    #   huggingface-hub
+    #   modal
+    #   uvicorn
+colorama==0.4.6 ; sys_platform == 'win32' \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via
+    #   tqdm
+    #   typer
+fastapi==0.141.1 \
+    --hash=sha256:bfb91aa2d334c61cb35ba9a116fc123b3d3df31640b801cf57a7a78ec3f603b3 \
+    --hash=sha256:e8822fc40db1e1858054d7a949a888695bc9bdce70139178e33bd2871a453ca1
+    # via mlx-vlm
+filelock==4.0.1 \
+    --hash=sha256:481a321a27bef441e23c53371c6abc8d7d16e26b97090074ba44f7538a3fd55a \
+    --hash=sha256:fdefc3f3e87716d855ae2b732c1cfd521dd99799ef2b4d00e8c0d4dcdc7cc94b
+    # via huggingface-hub
+frozenlist==1.8.0 \
+    --hash=sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0 \
+    --hash=sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121 \
+    --hash=sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c \
+    --hash=sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d \
+    --hash=sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b \
+    --hash=sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed \
+    --hash=sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b \
+    --hash=sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143 \
+    --hash=sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e \
+    --hash=sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746 \
+    --hash=sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8 \
+    --hash=sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad \
+    --hash=sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82 \
+    --hash=sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29 \
+    --hash=sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf \
+    --hash=sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62 \
+    --hash=sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383 \
+    --hash=sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52 \
+    --hash=sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d \
+    --hash=sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1 \
+    --hash=sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714 \
+    --hash=sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65 \
+    --hash=sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506 \
+    --hash=sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888 \
+    --hash=sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41 \
+    --hash=sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608 \
+    --hash=sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa \
+    --hash=sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1 \
+    --hash=sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231 \
+    --hash=sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496 \
+    --hash=sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a \
+    --hash=sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3 \
+    --hash=sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7 \
+    --hash=sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4 \
+    --hash=sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51 \
+    --hash=sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8 \
+    --hash=sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042 \
+    --hash=sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b \
+    --hash=sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e \
+    --hash=sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52 \
+    --hash=sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1 \
+    --hash=sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94 \
+    --hash=sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822 \
+    --hash=sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11 \
+    --hash=sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51 \
+    --hash=sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40 \
+    --hash=sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5 \
+    --hash=sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4 \
+    --hash=sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027 \
+    --hash=sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd
+    # via
+    #   aiohttp
+    #   aiosignal
+fsspec==2026.9.0 \
+    --hash=sha256:0f08147951c8cb31d844c3547d631053b127863b60be04cf06e121333ee0e2fe \
+    --hash=sha256:8dd6e646e99ea382bd85f97a45e6b526a442d79423a7dc673f1e2756d05fcb5f
+    # via huggingface-hub
+grpclib==0.4.9 \
+    --hash=sha256:7762ec1c8ed94dfad597475152dd35cbd11aecaaca2f243e29702435ca24cf0e \
+    --hash=sha256:cc589c330fa81004c6400a52a566407574498cb5b055fa927013361e21466c46
+    # via modal
+h11==0.16.0 \
+    --hash=sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1 \
+    --hash=sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86
+    # via
+    #   httpcore
+    #   uvicorn
+h2==4.4.1 \
+    --hash=sha256:0e25f1462b23c9cb82d9eb02e28bc706dac2a68cb457c6a0d74d63c8a2a5d0e6 \
+    --hash=sha256:4e866ffb1a869ae14dd9b5e6beb5c24a13da0495ad72b65925ded182521c1516
+    # via grpclib
+hf-xet==1.6.0 ; platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64' \
+    --hash=sha256:0e6e21fa3cdfcdcd76748564bf593870a5e013f47d97cf10aed63aa222cff5b7 \
+    --hash=sha256:2e58454a340b3556dfa4972d5451aff4fba8dd42a236600ba1a1d2b1514f0fef \
+    --hash=sha256:3dc3e35441ba395006af5aaacc40ef2e603c51ef46c3530b9156185f00935ea3 \
+    --hash=sha256:4fc74352a17015bd0ee90038bc9efe38db894cde45f268b6712b04fce8cd0acb \
+    --hash=sha256:633dc0cd71d32da58ab8c03ad38e2fac452c15c2b0a2866ebf6ededfe0a5061d \
+    --hash=sha256:8fb4f71cba6129110c3374a33f919001ff130488fc23553698e34cc1c2a1198c \
+    --hash=sha256:d62671bb130879cef0ee4c9ebe47a14af6c66ec53e6d84dc15936e5ffdfac82f \
+    --hash=sha256:f0906082d9932ae0c0057fa194041c22b4e2cdb46b2592ef3b91f020d62a081a \
+    --hash=sha256:fb4fadde1b2b70bf4c0c14a6dccbe7194b1c28947fefd5bbe3fed9d940676c3b
+    # via huggingface-hub
+hpack==4.2.0 \
+    --hash=sha256:0895cfa3b5531fc65fe439c05eb65144f123bf7a394fcaa56aa423548d8e45c0 \
+    --hash=sha256:858ac0b02280fa582b5080d68db0899c62a80375e0e5413a74970c5e518b6986
+    # via h2
+httpcore==1.0.9 \
+    --hash=sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55 \
+    --hash=sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8
+    # via httpx
+httpx==0.28.1 \
+    --hash=sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc \
+    --hash=sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad
+    # via huggingface-hub
+huggingface-hub==1.32.0 \
+    --hash=sha256:b0c7c80561969d9cdacdd55fce67ba9584cca0b9d4ea80957a3a5c1445fac5c8 \
+    --hash=sha256:ed70a45498abe86039df7c2f4e5f7575de524be908d3840e8f828d5525eafd6a
+    # via
+    #   mlx-audio
+    #   solomon-mlx
+    #   tokenizers
+    #   transformers
+hyperframe==6.1.0 \
+    --hash=sha256:b03380493a519fce58ea5af42e4a42317bf9bd425596f7a0835ffce80f1a42e5 \
+    --hash=sha256:f630908a00854a7adeabd6382b43923a4c4cd4b821fcb527e6ab9e15382a3b08
+    # via h2
+idna==3.20 \
+    --hash=sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44 \
+    --hash=sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+    #   yarl
+jinja2==3.1.6 \
+    --hash=sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d \
+    --hash=sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67
+    # via mlx-vlm
+jmespath==1.1.0 \
+    --hash=sha256:472c87d80f36026ae83c6ddd0f1d05d4e510134ed462851fd5f754c8c3cbb88d \
+    --hash=sha256:a5663118de4908c91729bea0acadca56526eb2698e83de10cd116ae0f4e97c64
+    # via
+    #   boto3
+    #   botocore
+llguidance==1.8.0 \
+    --hash=sha256:020b4ec2254a20555e69095c7d488907f17d7e65ab5a840b267530f2cb369f70 \
+    --hash=sha256:0eb7be70bf822e54cd4021bb200cfe2b86e4f3379d251067dc9f7da327f3ceab \
+    --hash=sha256:18d1579eabb040e65c870d50c6df19a7bef140c5260d12ad35b7f0dc446312e0 \
+    --hash=sha256:39668c11396896e5f05f59b70c81e4afd060b3408f02c8518b7a6943bfbb8a5d \
+    --hash=sha256:6ae4343bd40b88d1dd824a17edcee11b5e5a000b16b6fedb9fcf7f58d019177c \
+    --hash=sha256:6bf3953d06e7f5e24bd02fa6a89a5b2b88f7e811c0fa0228487d8267ef7cec54 \
+    --hash=sha256:79b0576991b8fc7534456b65c41d43c3183c8ca974a17799359af969c1489c07 \
+    --hash=sha256:a8837ac2b3bf4c46e1b6363012a22de043b7f8ef013b04d8689d471eb573b766 \
+    --hash=sha256:b5e866d8a896e255f30ec952f5280c61a3d6f391a9dce575ce976dd58f0b7000 \
+    --hash=sha256:bb9a89e8cdd7c8b5cf4f84e45b04177e79acdcc4d5116fbc775e511f7314df44
+    # via mlx-vlm
+markdown-it-py==4.2.0 \
+    --hash=sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49 \
+    --hash=sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a
+    # via rich
+markupsafe==3.0.3 \
+    --hash=sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219 \
+    --hash=sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb \
+    --hash=sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6 \
+    --hash=sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce \
+    --hash=sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218 \
+    --hash=sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73 \
+    --hash=sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c \
+    --hash=sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37 \
+    --hash=sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f \
+    --hash=sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d \
+    --hash=sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19 \
+    --hash=sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9 \
+    --hash=sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354 \
+    --hash=sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698 \
+    --hash=sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b \
+    --hash=sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc \
+    --hash=sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485 \
+    --hash=sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f \
+    --hash=sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12 \
+    --hash=sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025 \
+    --hash=sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009 \
+    --hash=sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a \
+    --hash=sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5 \
+    --hash=sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f \
+    --hash=sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1 \
+    --hash=sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287 \
+    --hash=sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6 \
+    --hash=sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed \
+    --hash=sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b \
+    --hash=sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676 \
+    --hash=sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e \
+    --hash=sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d \
+    --hash=sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d \
+    --hash=sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795
+    # via jinja2
+mdurl==0.1.2 \
+    --hash=sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8 \
+    --hash=sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba
+    # via markdown-it-py
+miniaudio==1.71 \
+    --hash=sha256:12bc33e7e61072b4b541c14e10ef76119d5643e6bbb98e2dec0c0738889438fb \
+    --hash=sha256:19be6f0a1e601c2237433e579734cfaf6469191b224c20c9e5f73c32ef9ee2b9 \
+    --hash=sha256:1bf93aeede652926f27f430f0fd69ef0cf8a949c07b537d6a2f295602c747037 \
+    --hash=sha256:4c849ccb1349f7b3553a77a66fe7e972315185f5c4c44a0bbda7ebcdd224db37 \
+    --hash=sha256:61b86f26d653040db32d9d15b05446321dd10e45beba25b44f841e26935213d5 \
+    --hash=sha256:62db602651bc20a2698f36a0d356d7217ed6f4f917550c7ffb3705c8e8be90cf \
+    --hash=sha256:70fa2ea5353e6919aca59b8c5768144af009d18c3bca251749d66fb497424563 \
+    --hash=sha256:8fc1a4f084cc1b4b25c567d22f54d1e46bfa505c17ed777c8b198e5c53d0f785 \
+    --hash=sha256:ab100e5240b104b5326e4ec1be07b6ae461f7d3d4d7a694857fd2f0493d210f9 \
+    --hash=sha256:d9dc15eff711bcfc62a9d05e0c78e4bc34821a455595e049629f2fea7491a523 \
+    --hash=sha256:e6287f15caa808a88aad0700a182bec1ff6d98769717425adf9ebf41259d1936 \
+    --hash=sha256:f4a44b70b66628b0c307e40ae0ae857695978cae18462179b806d8edc807d416 \
+    --hash=sha256:ff51e2887bb673e2e757752b586b3dc924d59aa5fbcae9bbc45f4a111bd3262b
+    # via
+    #   mlx-audio
+    #   mlx-vlm
+mlx==0.32.2 \
+    --hash=sha256:45857fadb381fea3db57d9681b04c987813fa883f3182ec9fb05bc56f468978a \
+    --hash=sha256:48e8738b078eeb7bfde74931fc02d8aa9c32f05d3c0dbf97b5c3cbe0470fbddf \
+    --hash=sha256:50ced716f4ab860cbda9d65adf74877923fe26036c4e28d8f572ecec57621cfc \
+    --hash=sha256:583111ec13fedf63ddbfefda77dabd57168978f06474f5e5d2637180d154fcc4 \
+    --hash=sha256:65beb9ce75153072808ef18913ecca3d929b87be5d7c1f57d9df391c04b6f957 \
+    --hash=sha256:65d3d29b66045ed8dd2d8e437c8770de325843c364f7b7c38cd8ae90a7eec854 \
+    --hash=sha256:68560fd648c5bb900aa6f6765cd74c5a8abaf092d97d73584a57b7545966c227 \
+    --hash=sha256:6c615ad1c6877d7d38affe8526446955cd48d6796e871150f59145cf0d1a265d \
+    --hash=sha256:77217798a2b036bae9f213b851d4cde4581893787c9964458b7d471f86036bd6 \
+    --hash=sha256:8d270ade1e48e006383a6b5f33a3a4ec5c265389299a60a60bf55165af1770d9 \
+    --hash=sha256:9d21abe340403b6bf445e8494590a7341b655739088c92f178d7bd4241ba0110 \
+    --hash=sha256:bc69bd1062b97028ae6b79522ed0bd635a2b133fe3c398c03b66b060c20d9240 \
+    --hash=sha256:c7670ffb854c11e6776349a3797fa076d1a2a00290ebe2e9cfed8b60ca4a5db0 \
+    --hash=sha256:c95a384de1a0c0ba18425344cad8ac87180e3c5c1921a42e2621475be5966bcf \
+    --hash=sha256:cf63fd5c32258ab07523b06401c20ee2280bf56e26e991d05bf6fd8a4d42d1f6 \
+    --hash=sha256:daebf84dfb857d70e87b1b98189a057e691e99a4a2b9f6f64cadebad917f8964 \
+    --hash=sha256:dc5eb3cc30d4285f2734c368442f717599e97294663441cb42959e3b856d6898 \
+    --hash=sha256:df8c75e509de868fca148dfeb38d92ce956eed386569c87caeb72bd16d2d6962 \
+    --hash=sha256:f6071e4973927966c12b3894deb75f4fcfc33300e0705312a80fdbbaa92a9c4f \
+    --hash=sha256:f77e47e6c1e176a61ec1bb1f9e74d874482eea6eb86ffb162a1f3e789c806453 \
+    --hash=sha256:fe813a4dee2daa6d5ac496ef25117034728c77fe26f713983a3b406eb6f4e8f0
+    # via
+    #   mlx-audio
+    #   mlx-vlm
+    #   solomon-mlx
+mlx-audio==0.5.4 \
+    --hash=sha256:3e1895860d9a636360a9377b5651239f5197e649d56fe25f1382cac6f2ed1e55 \
+    --hash=sha256:d350ecc43a65b94b1578381370be64229948f79aef9ff599d20adb65e38351b3
+    # via mlx-vlm
+mlx-cpu==0.32.2 ; sys_platform == 'linux' \
+    --hash=sha256:d0f94625588b51a878786dd51cec5617894ce586cf3c94645ce1b64e24c27c0b \
+    --hash=sha256:fc5d31b90fc4f457b2f9614ed45651a567d22a6a11a03d114a90a4e10bdd8878
+    # via mlx
+mlx-metal==0.32.2 ; sys_platform == 'darwin' \
+    --hash=sha256:3825fff379dbc107dd3413e564a06caeaa24819910ec49c0439e454c06a1b9b8 \
+    --hash=sha256:55a369250d220b2cf10213a87a2ac1b1a420608c5b35b1df4e7147ac8e32f121 \
+    --hash=sha256:e6abeac9ac5265830c9c1541b6f96e9be37a85c2446763a46ad466c63a3837ab
+    # via mlx
+mlx-vlm==0.7.1 \
+    --hash=sha256:b8abd3cc7e3513d9915bf9f6903833c697dc4c3084c2acdc880029c33e331a03 \
+    --hash=sha256:d9696bc3a2e961f43b5948a101dc0c966b5989d382e6910c37e2f3d555bc3408
+    # via solomon-mlx
+modal==1.5.5 \
+    --hash=sha256:30df363ed1898cc3d91a09ff3f95c38ab043f6b6294011b01085312c6a0ac777 \
+    --hash=sha256:8d10d3ee09818aaba1973b73ce2521ab8961b63a29b5b52e3ff0d25e7a74808e
+    # via solomon-mlx
+multidict==6.9.0 \
+    --hash=sha256:0db5bf96ec2ce45a8bc7fbbe8a486089969bb2791a66b6789ee3aed0d5dd562e \
+    --hash=sha256:1126782e3c3b1a7ccd990be3d3221709348e4b07d6ecf8b50965a93ae2624145 \
+    --hash=sha256:11e32ccf23cdbfcf8299a6a825930a858ec9a6aa05d6752d0f90f2bdf19489e1 \
+    --hash=sha256:1eb7939025bd9289d9dfe3a399102b1642f4fbb105a6af82f284052ee89e97a9 \
+    --hash=sha256:22067e88ff266e6a5dc59114529332692a01cc04b10dbdc2c14ab91217dee819 \
+    --hash=sha256:254e53be2ec70518bb82dfa9b0c7166baaf2bd0e918bd17b65caaf489d5a5522 \
+    --hash=sha256:2ea72901860ccbe94517421681c60b13533ce03ba2f7bd96293c3a4d16ac4ccb \
+    --hash=sha256:3e78870909e9f9e3d672ba99f1eb75130d7e01c42e642e6a70f434df32ca0ee1 \
+    --hash=sha256:3ec1e387b1f8a85ae5b94aa8c4e0576912ffa4d31bd0578f24c950d4f05ee476 \
+    --hash=sha256:408fac672931f2458be3bc8c89d9facd16dac2aad17c7cee2ca1693eee99f07e \
+    --hash=sha256:4bb769ccc72e15d7d441e1a08f169d418376be77cdc387e813129c26b357fe50 \
+    --hash=sha256:4be612f23990a261060ccd8f15e89dad1f9b7bb0c1021c5c3987f5fc57959391 \
+    --hash=sha256:4bef8cb5edea9c9daeb8396a75eeb97f912c3fb3fa408fe659edfecf91e47424 \
+    --hash=sha256:516fa4817cd070088f616a901380db56189f86daee9da79aada3c9b653f49ed7 \
+    --hash=sha256:51a08dceed4b42ef25755ee2cbf50df325e90e6b415d00955ffdea2c394ad6c0 \
+    --hash=sha256:57c2445049f7d8e66306f712868219da7ff7168ef42263dc032401211bf1205c \
+    --hash=sha256:640113258c5925a9eed2c12523410b25565ac5df2fa6735fbae88fb09bcdd212 \
+    --hash=sha256:662315f8621b3559268813b11134c1f9633edd4ab5f7b713688a243c13f4026d \
+    --hash=sha256:67bcff396d2ad62197c95488a716a88462792b384b5ea6e44bf7c1070eddb8fc \
+    --hash=sha256:67bed23e9803945b0760650ec3e903af772c49abe869f3bc03c66b2e7649d5ef \
+    --hash=sha256:6a5111a2bd824c821a3dd09da29680391b0caaa18fea7761358f4001e6898d1c \
+    --hash=sha256:75f7fc21ffce9a792cb919f0e0b0b52117bd672f2a55d1929d573b6fc437f374 \
+    --hash=sha256:7aaa14f0b9ffa2780c5d3b21da0e9b58778ed47af3369df72e5fd6dc10ff8041 \
+    --hash=sha256:85ed0f3c3b01174aea5a8a8fcd456f64c2e9719c0f42c612c2694ecd35974a65 \
+    --hash=sha256:8bb6be697065cbf31051465f9939d65624573d2219c3da8316db9e7cf5e0f5a7 \
+    --hash=sha256:8e991677c4bdc5d9f2e71c74717a4e32cfe98930ca05becdf722b5eae1329d6a \
+    --hash=sha256:8f06c4da5315a6f709b13408c3e13f3b475f8c559ec7608c3c67062512871235 \
+    --hash=sha256:91092d597fcf0940cd6a59e64ba7156ee22d6899993fd7c5b1897fda71482f8f \
+    --hash=sha256:95d339c3b75b4a50c665bdcf8417428cd71c3e5cd48e194cb1d336fcb856beac \
+    --hash=sha256:97555ad30ad20a8eb90fa86522088eebbbd68aba03e56d53f4850b3535c65e61 \
+    --hash=sha256:9869105ab61db13004f9ed610cd29ce4237b2c609f5f7b8bb8f2339fb9dad17d \
+    --hash=sha256:b33e499a7b1f722547d57b4865ed68c03161643b9afe49fe097a0832078d183d \
+    --hash=sha256:bb69b724c345420ba49187a17a894f146099f5b2e501df42ddb4452ac8be37fa \
+    --hash=sha256:beda95a6bd0a2e2265b941b90ff72543afbeaebb6a450e3a6a010d10d4a2ffca \
+    --hash=sha256:c51fd8d59e72e45c64907bf7f81fbd94f4c8dcd1c8b2f23f4c2d7ede788fcfc3 \
+    --hash=sha256:c7ab60b91e11b25e7682c5cd8763fdd17929ea83f234ba441091f1492e631ea3 \
+    --hash=sha256:cb847cb4002e725f88ffe29883da8290fd0754fa0461ed8988735e20964a9f65 \
+    --hash=sha256:cff3cff5a725bdb8359962de8d7429aea592d7693dbd197eeabbdfab9b6300e9 \
+    --hash=sha256:d7d32c0543494efbc9394e2b571725071d08e295993486bc9a43f6f89375ee01 \
+    --hash=sha256:e231de8ce43d4fd10bec4f67f71238ed88a974de30a9f20be7a4ab16c970a988 \
+    --hash=sha256:e4826f6b56456fb1e98111d7bc20cbdc7fa0a41b1f9ad80ff2dd3f2f5b226fe1 \
+    --hash=sha256:e71a072c52c78b7f97cd4611df6cef10977e4f2367cd0654a7626192f931adde \
+    --hash=sha256:f93c9058a0eceac0df2ce9d4c8823b84786ee598194753c2ca0c100224405e47 \
+    --hash=sha256:fca5b74b5909c29041f857c40d51d9273636fb4221cf020e4c452deb1c448a40 \
+    --hash=sha256:fdd484b84d3394e805689c56be3ab1f877ae7ff0eb9ff90a3ee7a755cbebab4f
+    # via
+    #   aiohttp
+    #   grpclib
+    #   yarl
+numpy==2.5.3 \
+    --hash=sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def \
+    --hash=sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0 \
+    --hash=sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f \
+    --hash=sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff \
+    --hash=sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034 \
+    --hash=sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec \
+    --hash=sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58 \
+    --hash=sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204 \
+    --hash=sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e \
+    --hash=sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321 \
+    --hash=sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0 \
+    --hash=sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034 \
+    --hash=sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3 \
+    --hash=sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231 \
+    --hash=sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4 \
+    --hash=sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b \
+    --hash=sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9 \
+    --hash=sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034 \
+    --hash=sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958 \
+    --hash=sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563 \
+    --hash=sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c \
+    --hash=sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09 \
+    --hash=sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e
+    # via
+    #   mlx-audio
+    #   mlx-vlm
+    #   opencv-python
+    #   scipy
+    #   solomon-mlx
+    #   transformers
+opencv-python==5.0.0.93 \
+    --hash=sha256:08d5d91d967b58d6db86073b2ad3eaef88ca4ebdfd45c9059bf59f5ded0c7ad2 \
+    --hash=sha256:198a75138241810206a17c829dbcc40a7cb1841cda538ca86cbbfc6c7d95f898 \
+    --hash=sha256:4b4b1a34c79bf8d3738e3cfe9a9e67b51a79663f6b692cbdad8c31f570da4157 \
+    --hash=sha256:66aac3e5b5faa48d4025816592f3af19e4bfc2c68dec067bae2dbb4ca10aa9e2 \
+    --hash=sha256:6bbc32f59e1b1a7db7b39c81f63d00625f041d333037fd8702f6da52cc39108b \
+    --hash=sha256:c8de2dec111122a02e8beb28e16c31904992dfd6186560b142a92c71403c1039 \
+    --hash=sha256:e2b4272e736836f66c2d176e43ab8101f3a00d45654916399f52e150c58981ac \
+    --hash=sha256:f8b6d0a212253dd26ad338c812f1f23ca118fdf05a9c8c6b9444f161aa8c5881 \
+    --hash=sha256:f90ba04b8f73bc5c3814037699739f0156f597338a98f05956c684e7c3ca10d2
+    # via mlx-vlm
+packaging==26.3 \
+    --hash=sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79 \
+    --hash=sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c
+    # via
+    #   huggingface-hub
+    #   transformers
+pillow==12.3.0 \
+    --hash=sha256:0847a763afefb695bc912d7c131e7e0632d4edc1d8698f58ddabec8e46b8b6d3 \
+    --hash=sha256:0dd2064cbc55aaec028ef5fbb60fa47bb6c3e7918e07ff17935284b227a9d2df \
+    --hash=sha256:1cca606cd25738df4ed873d5ad46bbdb3d83b5cbca291f6b4ff13a4df6b0bbe8 \
+    --hash=sha256:21900ce7ba264168cd50defae43cd75d25c833ad4ad6e73ffc5596d12e25ac89 \
+    --hash=sha256:331b624368d4f1d069149002f25f44bc61c8919ce8ddb3c45bdad8f6e2d89510 \
+    --hash=sha256:3b8182a766685eaa002637e28b4ec8d6b18819a0c71f579bf0dbaa5830297cce \
+    --hash=sha256:4e8c2a84d977f50b9daed6eeaf3baef67d00d5d74d932288f02cb94518ee3ace \
+    --hash=sha256:571b9fcb07b97ef3a492028fb3d2dc0993ca23a06138b0315286566d29ef718a \
+    --hash=sha256:756c768d0c9c2955feb7a56c37ea24aea2e369f8d36a88da270b6a9f19e62b5e \
+    --hash=sha256:78cb2c6865a35ab8ff8b75fd122f6033b92a62c82801110e48ddd6c936a45d91 \
+    --hash=sha256:7a743ff716f746fc19a9557f60dab1600d4613255f8a7aeb3cdde4db7eb15a66 \
+    --hash=sha256:a2b55dd6b2a4c4b7d87ffa56bdb33fdc5fdb9a462173861a7bc097f17d91cb09 \
+    --hash=sha256:a876864214e136f0eb367788dbd7df045f4806801518e2cfe9e13229cfe06d8f \
+    --hash=sha256:ae26d61dfa7a47befdc7572b521024e8745f3d809bd95ca9505a7bba9ef849ec \
+    --hash=sha256:b629de27fda84b42cde7edef0d85f13b958b47f6e9bbcbba9b673c562a89bd8b \
+    --hash=sha256:ba09209fbe443b4acccebe845d8a138b89a8f4fbaeedd44953490b5315d5e965 \
+    --hash=sha256:d69141514cc30b774ceea5e3ed3a6635c8d8a96edf664689b890f4089111fb35 \
+    --hash=sha256:d9c7f76c0673154f044e9d78c8655fb4213f6ca31a836df48b40fe5d187717b9 \
+    --hash=sha256:dbce0b29841537a2fa4a214c2bbf14de3587c9680caa9b4e217568472490b28f \
+    --hash=sha256:e491916b378fba47242221bb9ead245211b70d504f495d105d17b14a24b4907c \
+    --hash=sha256:f7401aebd7f581d7f83a439d87d474999317ee099218e5ad25d125290990ba65 \
+    --hash=sha256:ffd0c5368496f41b0944be820fcb7a838aa6e623d250b01acf2643939c3f99d7
+    # via
+    #   mlx-vlm
+    #   solomon-mlx
+propcache==0.5.4 \
+    --hash=sha256:0c889f6fa84957bc7e8b4eab71fd16a0455068d5045e3aa40c733071d2b2fd77 \
+    --hash=sha256:2814ecd8e818f487bee4b0f921bc4d1c176cc5fc71ac0f072d0fa67eda4ac14b \
+    --hash=sha256:36c0d9db44b523ef93d03341b1c42d69ff01d673c053d1b1c6c3a363bcaa39ba \
+    --hash=sha256:3e413d7a4a9b4866b7a761d6060d434b64d23cd35122eda3b026a0bbe8196b25 \
+    --hash=sha256:425f8cc86ab5018b4b8d4a23bc8e74d964bd3d757c3702e301aa79be76c53f6c \
+    --hash=sha256:44149f46500a0a41b95b4d99c2e586a77319539730607b9892974a092788b111 \
+    --hash=sha256:4fbc1a15dc8cd1689508758d626b372b1f09d28d9577667feaf9e6bfcd8efcbc \
+    --hash=sha256:60a64cbccaa11b7760ce705a14ada17ba459e7ca9f23ba587eb013821032d7ef \
+    --hash=sha256:62c60aec739ed00124573cce1178138fd690c7676352d67a37328c1cf51d7468 \
+    --hash=sha256:69fc35c0779522da366c563e5faf203ffc1f8ff0021d5b1337fa4efa5be73177 \
+    --hash=sha256:6af4693716bfb03f1752ef1b30faa593db2c01d5272e9b8564a1549452a979ab \
+    --hash=sha256:7cc528e760a8af06f2b13e9b9f362cd90c7c718ea61228a96dbd31ba16ed7f47 \
+    --hash=sha256:7ffafcbfc7b549ab940047e505c831eabac5e67de53e1bc174adbc5285c55944 \
+    --hash=sha256:87a3caecf8095e48dc72f84bfa42e23a848cf410cc9cc13031fba4869b706a21 \
+    --hash=sha256:8876b39961e33d912afe3c1bee18ee564fdad0206f873cc15d522756b7f50737 \
+    --hash=sha256:8a235f73d6e020855dc29dff012d920c02ee0feab8d73a24185a7569f4be1161 \
+    --hash=sha256:96f7c5c15656040ddcbc51e56dc59b58aa25999d743c126abd425b9766ab43e9 \
+    --hash=sha256:98914de2c4d7f0f9f4a8c6ea4bf05841f4175796941e3ef7d47eb718f22311fb \
+    --hash=sha256:9a2a8a50a93dee0268a860a07fa3b4bd968f8ce4dbd794957da772f395368526 \
+    --hash=sha256:a4d7a54719b67338a305dca2ce6aafe366817df94ddfd4b5514374356f5ca546 \
+    --hash=sha256:a5793c7698a53f56f4a1889a4737c7eeb1b7ad0842fa6b1abca22913ff79c8c1 \
+    --hash=sha256:a74bfa37147cc08fb29df10bd9c16f40fa7f860cd3a6d2fff853323a94f6e17f \
+    --hash=sha256:ae58f361bd5dae942717c65d3413b478c70aea9c462599e7b9adad3731db3894 \
+    --hash=sha256:b28f41fa3b8c6900457f858ec5b03998f3a6d535fbc1bb2edec5961ea05ec429 \
+    --hash=sha256:b3083bfe87f95c756e610bd8025f26cbd1cd4aaa03a422f2d65efb7a97cd53d8 \
+    --hash=sha256:c02c0e570c5c7e077b0181a9f3cdb7d4c3617d1cda6b5c95bd5d34022923d82c \
+    --hash=sha256:c2ba30a89035b57b73e00475de948521602f543d79ce01db10b04b36c4c76fc8 \
+    --hash=sha256:c3e98c55bde2bcf7db3c70d1aed7ae9aa8aebbf19a250c66645cde44cdb8b867 \
+    --hash=sha256:cdee8205a44d0be91bbac4c41b95d86641b72dfc7aef1279400e4fda3f26a937 \
+    --hash=sha256:d1f5a500bfcbb2c0ab85e98a0dcd70f5899d34efe365a0187700369a79603031 \
+    --hash=sha256:db3ae52ccc150dbc84704e9d642743897f3e1c54742ff34cacb661e52e3818a9 \
+    --hash=sha256:dbab5f5ff6897c81f355d079010cdae85b02e5a0b518b5251523b8ad8ae9ac3c \
+    --hash=sha256:dcbf346a318a5e30063f547630b02bb787ce2f45b6368d5da143660b6a3835d8 \
+    --hash=sha256:e1d52a05dc417279f7e5c7618c5dfbbc29923aaf9bc0a5c1802ddcebf54c61a0 \
+    --hash=sha256:f85915e00dcb1cd9f2f890ead064ed40a27df06f0db65be427b29482ae357572 \
+    --hash=sha256:ff6b113f50bc066a698db5d944d2c6dc7507168dd3341e255a8892fd0715a558
+    # via
+    #   aiohttp
+    #   yarl
+protobuf==6.33.6 \
+    --hash=sha256:0cd27b587afca21b7cfa59a74dcbd48a50f0a6400cfb59391340ad729d91d326 \
+    --hash=sha256:77179e006c476e69bf8e8ce866640091ec42e1beb80b213c3900006ecfba6901 \
+    --hash=sha256:7d29d9b65f8afef196f8334e80d6bc1d5d4adedb449971fefd3723824e6e77d3 \
+    --hash=sha256:9720e6961b251bde64edfdab7d500725a2af5280f3f4c87e57c0208376aa8c3a \
+    --hash=sha256:a6768d25248312c297558af96a9f9c929e8c4cee0659cb07e780731095f38135 \
+    --hash=sha256:c96c37eec15086b79762ed265d59ab204dabc53056e3443e702d2681f4b39ce3 \
+    --hash=sha256:e2afbae9b8e1825e3529f88d514754e094278bb95eadc0e199751cdd9a2e82a2 \
+    --hash=sha256:e9db7e292e0ab79dd108d7f1a94fe31601ce1ee3f7b79e0692043423020b0593
+    # via modal
+pycparser==3.0 ; implementation_name != 'PyPy' \
+    --hash=sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29 \
+    --hash=sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992
+    # via cffi
+pydantic==2.13.5 \
+    --hash=sha256:346a034f080da3755d8e9cb5e00e8b07de1d39e4f6e2c87d8ab7cafa0b269a73 \
+    --hash=sha256:51a9c5f7b2f8e636f04c6cada605d9b6a3bf1348fdf945a3d8869b19bba0ee08
+    # via fastapi
+pydantic-core==2.46.5 \
+    --hash=sha256:013d6f3483d81e02e7c328831808f336c8596ee33b4bd4026b9ffb1e960b8942 \
+    --hash=sha256:0fc5be0abd4a407e200d844b404e33639a554e7bd0d448e7b9ae181be4789ac2 \
+    --hash=sha256:10416c15b8839ecc4ef4d0885da76da6fd0f67333a0eb8aff6d93c4b8f2910fc \
+    --hash=sha256:15f4a94963c95accac15b7b657bb177d3ad82bb90b0d0526d9a9b85079925db5 \
+    --hash=sha256:18a09e1e1011b462f2e32774f25859ef1223d5c2b0546a633cf56654710721e0 \
+    --hash=sha256:193375f3548919d3f0b60936ca113ada3e38f264f91b9b8e0508efaad57be931 \
+    --hash=sha256:24922243639cbdac66c75fcb6fd6495a9cb52b213d62f9a0d16f0310b1ff8038 \
+    --hash=sha256:2bc9419666990c06d7397831f2126a1ecc3594aaa3ff7de5bf2d066802f4e07b \
+    --hash=sha256:347ec774390c87326a2e4929d58d3f7e8763a104d5d35f4cd595a4c952366433 \
+    --hash=sha256:4fdc8b93a41521988916eeaa271173fcca7fa0803d62f87675aac8dcec1c8e29 \
+    --hash=sha256:5cb482e9e84c851f4e623fe4acc1ced89168cf1fe18f7089db4548c8f5bbb65b \
+    --hash=sha256:5e81740c09e310f5aa5cbd3e434a01c154d4bef93241c7877b39f211d2b78ba8 \
+    --hash=sha256:5ee239d575f80b08eca11f6e20f90c4c695de7825c67eefe6091fbf20dda648e \
+    --hash=sha256:6f7b393a8b3da82f5c1fc0751e6d01ac6c55b93c18226a60bdfba4a724efafd1 \
+    --hash=sha256:79bdfa52f843137045b2d081cc05c120ba6665d29b7559c2c47690906f39279f \
+    --hash=sha256:7ac031912d54f3d83ef3b3eb98dfabc1608802e2202263d25957eeed40b94761 \
+    --hash=sha256:816ff0a6550ffc06c098ccd2e0698600f9aa7da192a79eaa6f9af504a35db869 \
+    --hash=sha256:837b396ca3d7b74091ca623f6cbd8351bd42d670a79c2683e79fb089f06a2de5 \
+    --hash=sha256:8e24d8f05fa2d28513d94e877e9c75ad66175376209b3977f916e240e623193c \
+    --hash=sha256:97bf8de4d541598c94a59344eeb988a94c08ff76b5723c41f6567ec18c7892ea \
+    --hash=sha256:9c4b71f10dd532fb7a5cbc8f58707779e64f03a258c2bf8bfbaecfcd9970b519 \
+    --hash=sha256:a39ac25a9a2fa4072efdb429833c4a4c8009a51ff9eea3eeae131713cd27991e \
+    --hash=sha256:b7ca9034437b6022f941f4857459562ee00a560b97e7cce8a0ec5a74fc6766e0 \
+    --hash=sha256:b98134087d9de723658d17a42c7d0da8d6e2ef08015dee7dc93889047315f5e4 \
+    --hash=sha256:b9fe6fb92520e3fd61f2e49000b6911b188824f089b75973ea06d6267f0b476d \
+    --hash=sha256:c76fe65e607be28c7fd4d56fc3c42b1583aa058ce3408b7ad0fd540171d31f9f \
+    --hash=sha256:c7ea57fc63aa7da93a1bd2d644e6577befae10c52c4e36377635eea1056a74f5 \
+    --hash=sha256:d22a945598fb91236b4dd793a6e42e4f3dd7740bb5aace5ebd7d4c08d13bb575 \
+    --hash=sha256:d925f3d9afd05a8c0fb3a1031463a8d59ebe5e2afad297e29c78be19e13b4e62 \
+    --hash=sha256:e652ab17569c94bff5475520f907b7148b8c24036a8ebbe5cf7cf7493d28579a \
+    --hash=sha256:e80675d75ae2cd14372cb65cad5400d9347a3d3f6c13000183f22dfd027283ed \
+    --hash=sha256:e9c134bb666dd54b778b9fc0d2b50cbb7f979b9e3716f26a88c9ab3b6fc1dd0f \
+    --hash=sha256:efd62a42486f1bda5d24cb4f63d15a3c7768375fe83d36f9417b4ad7a2fb20b3 \
+    --hash=sha256:f332f0e72a5a0400141f830744e141bf9f97917878dbe968669e8a7fefea78ff \
+    --hash=sha256:f7b0ec93a2893de856652154d73b7ba622f26fa97726487dcac373de5f4c6084
+    # via pydantic
+pygments==2.21.0 \
+    --hash=sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9 \
+    --hash=sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c
+    # via rich
+python-dateutil==2.9.0.post0 \
+    --hash=sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3 \
+    --hash=sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427
+    # via botocore
+python-multipart==0.0.32 \
+    --hash=sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e \
+    --hash=sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23
+    # via mlx-vlm
+pyyaml==6.0.3 \
+    --hash=sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 \
+    --hash=sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1 \
+    --hash=sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea \
+    --hash=sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb \
+    --hash=sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b \
+    --hash=sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c \
+    --hash=sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd \
+    --hash=sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c \
+    --hash=sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196 \
+    --hash=sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8 \
+    --hash=sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e \
+    --hash=sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28 \
+    --hash=sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5 \
+    --hash=sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5 \
+    --hash=sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc \
+    --hash=sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26 \
+    --hash=sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f \
+    --hash=sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be \
+    --hash=sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c \
+    --hash=sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6 \
+    --hash=sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0
+    # via
+    #   huggingface-hub
+    #   transformers
+regex==2026.9.10 \
+    --hash=sha256:032da15431c890d376f53547f0a6219f4f4cd19f3e4f11bdc321453b5bd207e4 \
+    --hash=sha256:048a89ee797db10160bd2bd519286577a6b43a100279bd4b7d8456a3d69c80a0 \
+    --hash=sha256:0c32480f3371b75068decaf9e5da72c224e953830dd71e36e06cf80e30ea39d8 \
+    --hash=sha256:1562aabd9d4eb09bd88a62ad97ed06800094b529ac43419e43020b9cefec79b0 \
+    --hash=sha256:1e321e2c84f0e52c457f5ea5944f796d6e8e09cb99738ea98dcc1bfe402a128d \
+    --hash=sha256:20e8bfb07ad79a282f8b95b56fe67f9750b1b7f775724e4ba1f23cb296115ce4 \
+    --hash=sha256:239620b0e0681669367c0e218c8eb2551d9f8fe3b9fccfc8d0003377804e8348 \
+    --hash=sha256:23ac9a28180f274d7dd7651fa131ad5b02d343b75df4b040737f0356223895dd \
+    --hash=sha256:2479171edccced52ef02b899558f88ab2c235fe05b93180fdcae1670aacd89e1 \
+    --hash=sha256:2e67f8843f0e4b931f1fa860bf3bbe4134b714c0155cc5c7c0d7ea450230aae0 \
+    --hash=sha256:3bdeed3318a8eb2bbadc9c56347e0ff651639e934a47e168d05a3b12929fd0e7 \
+    --hash=sha256:4c66d54042a14a503907d81861b8a5235e6d1f03d4fbc1d8767f652eaf957ac1 \
+    --hash=sha256:4db7d00c4afbfbb55b8e17b1e371da11418ea9389b030acec63c1fa4c7ad4b86 \
+    --hash=sha256:5847e22bbf959764d776937d791d034cc2d19b787e361c88d97e859e8dc68502 \
+    --hash=sha256:6aebdd9a946de328b3f6f61dbf48dd064a36eb6dddf96e34ae6651d37f6e9383 \
+    --hash=sha256:6b34a778c695d24e77c140e3b4c95da69282e34f2f6b02b55656aa4a0379f643 \
+    --hash=sha256:79e9432995e14c749d34209413de5e621ec8e67789bf4f46dbfabea9d06a2406 \
+    --hash=sha256:7abb38b8c40f3a235235a44da452c64b7b5c1d650ec6351027db0e090804f2e5 \
+    --hash=sha256:866de9f98df0611d7b62b3a8729d3284a64c0cc6edd90bb95a533e443a4939cb \
+    --hash=sha256:880ac684c27176464c00c3fdc456116364f5ebc70da07aad0c2d4a7ba45e98db \
+    --hash=sha256:b9d36b03dc362aa40ffaaec9d9bd75e87763529563ec008c43b0e07782f5be7a \
+    --hash=sha256:bafa41b0dd63669e5c0f8adf3d24819efeb73c847f492eb011212eb352e69041 \
+    --hash=sha256:bb7774924f8cd69f49cba0b3c2d679a6326f777e0e67d130ad5203e4df53f0d3 \
+    --hash=sha256:c014641157e9049b0603b8daa5343bd408d9b757b709aaa0f373cd3fab2d7944 \
+    --hash=sha256:c103b3b14e011774af4fb7e4617ad4d72b9171905cd3b231a70a4efd76e477d7 \
+    --hash=sha256:c25a754bb81a2edcfc3b65eda50f017d736f818112ed43e8aafd595cb00678ae \
+    --hash=sha256:d2d377fd1cad611b806cdd732d86b65f536c768209890cb442556548daa65a23 \
+    --hash=sha256:d8c668af8f7bdb1d18739c27d30cd9f4b371495a883f75a002fb7a39d740fecd \
+    --hash=sha256:dce932f8e3ba936475ea3d0d8b59f7b050a9e206e994f53f8fd80299871e87da \
+    --hash=sha256:e0dc78251154b66dc60211563fc115345da332eaa881e4e2523fb1edae3772f4 \
+    --hash=sha256:ebb2ba68e4641a994061f70bf44ed448fba0b9b1d18c94ffb9efc1cca805b39b \
+    --hash=sha256:ef5a059ea1c6ee5d1c7e99a2484e628608d010921efe876c6f0e2029d2f35eca \
+    --hash=sha256:f2374c27deb189b282ec7e16106752c22ad39b056bbd8018960b1e4cc95d67a1
+    # via transformers
+requests==2.34.2 \
+    --hash=sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 \
+    --hash=sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed
+    # via mlx-vlm
+rich==15.0.0 \
+    --hash=sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb \
+    --hash=sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36
+    # via
+    #   modal
+    #   typer
+s3transfer==0.19.2 \
+    --hash=sha256:ba0309fd86be3c27dbf78cdd813c13c5e1df16e5874b99d2535ebbdfb9892993 \
+    --hash=sha256:d8168eccca828cbb2cd573675333f3bddd254313a9c42494b84c76b539e8ba25
+    # via boto3
+safetensors==0.8.0 \
+    --hash=sha256:040070828e36dc8e122178bbbd5830ff9e97920affb84cbe0f46442497bed358 \
+    --hash=sha256:096ec1a98435df7beb08853bb5aa9081a84f23d0adc67ed1a0a10550f608373f \
+    --hash=sha256:2ddf52eac562eda224f99acfa7889d02968c1fd59a5b011ae7d8137c37e9c02d \
+    --hash=sha256:3ae091f16662658bdc019a4ff6cb4c085bb7d725eb5978b183ffd265863b6d2d \
+    --hash=sha256:4124502b78f03534117c848f87a39b8f31e577b15eff423bf8bfb95f2a8c30d0 \
+    --hash=sha256:4a95ae2b05d7726d751da4ebf626a2ca782b706e101bd894c95bc2450b1cffcc \
+    --hash=sha256:7a46e5ff292c356d6991e60942ba7f79817682d3a2cef0702136448cb9c4d235 \
+    --hash=sha256:7bc0a787ba8a35be368ee3574edfa2b1ad389eebd0a72e482ae275490e3f6c98 \
+    --hash=sha256:87eec7ffed2b809f05a398a8becb7d013f19f7837cd15d9748580d6cf30dbaf4 \
+    --hash=sha256:8e080062fcde23be189565e1c3305d16751a218ecf9412c8601e64204eb6f846 \
+    --hash=sha256:8e9f537aa183a38ace122d27303dcd986b26bd2a7591f9181d7f0c396f4677ca \
+    --hash=sha256:c554f85858e05226d3c2828e32395e677434685d6d94594a41643361c5e837f0 \
+    --hash=sha256:c80201d22cbf405b80647a60ada77bba06c8fba2da2743ba1e89cdcc39a81f25 \
+    --hash=sha256:f7838e5135a406ad3e02efdcb8cf2e5397d368b0154537c4fec682dbc544d452 \
+    --hash=sha256:fabaf3e0f18a6618d9b36560682562157f77c2b71fcffc7b432be2baed9d753d \
+    --hash=sha256:fcdd41ec4628fee5799f807c73c353629130fbd942aa23d83c623dd6c9d52d78 \
+    --hash=sha256:fd6f3f93c9a0a7cc2788ee63fb763353d4bd2e89b0751bc78fcf7dda00bea774
+    # via
+    #   solomon-mlx
+    #   transformers
+scipy==1.18.1 \
+    --hash=sha256:3ab3523da44749156e1f68b464dc56af11ae4cbc5c739a49d05f32b982eca9f3 \
+    --hash=sha256:3c085faa2cfa879c5141df483f836f4d691045a078224a670fa570fa01612d89 \
+    --hash=sha256:457fd7a2a8edeb044ab6ffbc0aa03ff6cd18491356e5e0c834d76ce621b916d1 \
+    --hash=sha256:52c4b7422442aba924d03ad4019852b08a92e64ea187b933135687bfe2747307 \
+    --hash=sha256:559ed65f60c1af5a03f3912605a1b5114f522c7c32fb23c3376ae8f03219fe28 \
+    --hash=sha256:5e4d44984abc0020154ea81b247adeddcc3ac5527b975ff798bd1ba0adc513c2 \
+    --hash=sha256:75b00eb8fb802090aa903f4ea1c7f5a584779f967361e68b7e98e531cc2d7174 \
+    --hash=sha256:78c0665edead396b1abb4897c41a5c1d9bf090c8a637a4c20a61678e0a264e66 \
+    --hash=sha256:7bbf207c4453ce1ad2e00b17313852b33310b83090c2311bdaf97f93c0380d12 \
+    --hash=sha256:c35d74ce0e193ff740c2f2be2ac913ddc232fe6c1ff40b26cfecb9c670c63314 \
+    --hash=sha256:c825cef2f49e46753726a7181a8e199804a912b29519ada542c6ebc654951899 \
+    --hash=sha256:cd479fc04dd9401e3b4f49e76518768ef99c4f517a98c284eb091fd725719adf \
+    --hash=sha256:d2924a03db38dc2e848bca2fe9f077dafb891480b91a00a0963a8cf86dfc31c1 \
+    --hash=sha256:d416b16cccfd70fbf62400e84d0bb2f4e6af519a45557f1692c749b37f14b315 \
+    --hash=sha256:d65d448389b8436493abcf629cc94ad0cf32aecaf06e1acca1de53cc795f2f12 \
+    --hash=sha256:e3b417bf8c2c7c16e8f58ad91db17783ec911ac16e7b50eb6eab6e809b4f5b07 \
+    --hash=sha256:e6fb6a55cc0ba97b59a1f288fb86dc6fce8bdfc0fffcbfd015e3a954bf2a2d93 \
+    --hash=sha256:e708533e8b2ae2497d65346538a7dcc92814410b25b81432eac66de0f2af8265 \
+    --hash=sha256:ea324d9dd34c38bfb9bec8ca4d1b407db97dbb74029f566b8e322b1b6fe56fe6 \
+    --hash=sha256:f55fa87b6c612ecd6b058f167c53231b1d14e412efe361d3d6e38b3631c73218 \
+    --hash=sha256:fdaf5ea890a6183d0565f51a61799d67081bd5b1cf03c5f4b3fd3732108625c9
+    # via
+    #   mlx-audio
+    #   solomon-mlx
+sentencepiece==0.2.2 \
+    --hash=sha256:1edb10e520e4bddf74d85b0f5ae74cc2d60c2b448885080bfb618bc2b3a49f6b \
+    --hash=sha256:201a8e0f55501a76e08dbf2c54bc45f4642b379271e89c667d517bfbc2191f2a \
+    --hash=sha256:38111ed1f79268f399c505028023d5eaaf0ab4e5eafceb709468b0d3323e7838 \
+    --hash=sha256:3ab3f1ae98970b5590e2209341522718900ba19bcc2c207ffaa6bd417ad960c5 \
+    --hash=sha256:3d2b5e824b5622038dc7b490897efe05ebbbb9e7350fc142f3ecc8789ef9bdf6 \
+    --hash=sha256:3ec27c152a1f1b24bc9168b55a5880f3c16e2334e697da6f55a1046a22405a3d \
+    --hash=sha256:4f0603267cd15b92b68c2c0e852a441507614b70dc7773659baa6b8c214a91fd \
+    --hash=sha256:59d6588712101ccfcae9b03692be3aaae1514c2078666d7b05f15ba3a702e41b \
+    --hash=sha256:64b656f025355cf8c51abe9fbe3848540756c6d7ca5e6791b1afa664bc24c7cb \
+    --hash=sha256:72b7825b331b1b7e7c45be2e674b3e3c65af608fa376bad2d851b20aaf0cdc78 \
+    --hash=sha256:74f0ee601047c0c12a783088b51be4e6214a62ecd9e02278c477433cd16e0ed9 \
+    --hash=sha256:76ff5814db72e7462dece042d7593cdf102b8ec82c2b1cc201a2add34ee3050d \
+    --hash=sha256:77c3ce990b23441e5ecfa5bce181fd6f408b564aeb6d7e1d1e7de9c5612501c8 \
+    --hash=sha256:7c6e7bf684dc12145bfa685d3060beaea55139134ba848289bee514ed42e7383 \
+    --hash=sha256:89625fb43765cccaa1443b9adb61f283e5fe4cb1536728205d06bada730caa53 \
+    --hash=sha256:8eed98514bffe5ecac37f493f91869c351fbb05629328bfdbc08502c6c094dc0 \
+    --hash=sha256:b23fe17779834d3c27aaf2edac9486d04cca1a7deb8f5facda35150ac6263a91 \
+    --hash=sha256:c8a168b040bc61681293f79a949b5d911c8e25086f4260285b8d97ab5f1195da \
+    --hash=sha256:cbce24284f51f71d10a42b7b9c964dcb9048b28f1c8e5db40bcbcb6f428cba6a \
+    --hash=sha256:d795c4ac689a57f9d4ba2288126ec7901d389ad5827d2f8b8533c883974fe563 \
+    --hash=sha256:f7c06c751c19d923435a54bff4f7e66e728fad160e8da28254f133abc9725820 \
+    --hash=sha256:fd523c4992041faa5c2b3cde62253d11a96c30d73a34afe48a486e8e2254cd1c
+    # via mlx-vlm
+shellingham==1.5.4 \
+    --hash=sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686 \
+    --hash=sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de
+    # via typer
+six==1.17.0 \
+    --hash=sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274 \
+    --hash=sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81
+    # via python-dateutil
+sounddevice==0.5.6 \
+    --hash=sha256:7f4162f514f007b0bf25a3ccfed3f1705bc2ec311888a90232729eec4f57a4f4 \
+    --hash=sha256:8ec9fbfde2e32f020b167e348f3ab3bac6625a5f15af524d790108ac7147a410 \
+    --hash=sha256:b36b807eb02abd257198bf84b2af05e4fea199a9d2f0019014169c7136d45e9c \
+    --hash=sha256:c8ae19173e5f27f8c12d4b5eee2dbfe542cee125d591e663e0fb4dfb75246d45 \
+    --hash=sha256:de099612311ad81e55d31ccbd83f43ea6bf4d87b48f9b6ea55a1fbcde0eee4e0 \
+    --hash=sha256:e3aef00ad8b1d1740eb66d9a7671eab88a4d2b8fa4ab33498d742e63b65c309c
+    # via mlx-audio
+starlette==1.6.0 \
+    --hash=sha256:a86dd39d14bb45f85a3d18525215a9ef0cfd1f192ac793220e72598c90335f0c \
+    --hash=sha256:d4e3ac5e546444960c710297a3c9fc3f7ebae1b7e963f3d36173b49da535be9b
+    # via
+    #   fastapi
+    #   mlx-vlm
+synchronicity==0.12.5 \
+    --hash=sha256:94d96b1d85698e3056b96a793b8c0949af6584e4a7d877fabdeb5385efe230aa \
+    --hash=sha256:fdbbb10d437bc08a6b0f814fc66fddd1b58ffed314533d42f1ab555801e781af
+    # via modal
+tokenizers==0.23.2 \
+    --hash=sha256:12f0835dc2ee694746a76adf7b1567d4346a4a502ebe93fb1f5f80ea49799b78 \
+    --hash=sha256:2e96f5699d5249c9c64aa8412e044f727aae3a4098cf830f9901ec1afc361cde \
+    --hash=sha256:325fee2e0418a9dc6c9ecf736a5f5f0db7875183ace9549ae339da76f7a1fbb7 \
+    --hash=sha256:41c2f84d172449b4dadb9cdc508e3e364076613c35b16e76ecfe47a60d1e3305 \
+    --hash=sha256:43e4f2071e3cc8d5d86421c874aebc82659bb51a68bcdef5a0da75ee89511ccb \
+    --hash=sha256:5c56bda1511921587789163e524d196ed8284174ac23abd7685d5ea8da6c4718 \
+    --hash=sha256:7b7e37ba198f24150f523e1242e83c4970de4a525480586be5dcc24d9add32c5 \
+    --hash=sha256:7f0f085686b9de0d0079e6f874ae053600db64c5d13049e0bbc0119926d25aac \
+    --hash=sha256:85a9a357a3764aecc904ee76bdaf8cf1ad8e5a67a1b929a487c4a39b49ed0e90 \
+    --hash=sha256:950d7c9426fa72406a0ffeacdbc0bb9985f5db20eb8b263f29c79aaf83105703 \
+    --hash=sha256:986670e43691469dcee610ea0f846f91a8f84e91fc6f7a48d4c064414c0ec2bf \
+    --hash=sha256:a37039b5dfc4af84eb3ef0a92f4307e28936c8f9adccba2629d36f652e9bf7a2 \
+    --hash=sha256:bef235815a067b2648caf6dcc7a71091b0b0fff9ee8057f6451eb9335fae52ef \
+    --hash=sha256:debf978920d93ba9c219bd67cc4bbfaf912c9039e41e7a28b91ec15e3728c95a \
+    --hash=sha256:e49c394456dd9985787fec76132438ba3fb8911f857b1bf3d40119f9292d41aa \
+    --hash=sha256:eb2f9c8a24da020ea8c11a01a19c1c2547912d92121ae4a01cfbca46125dee40 \
+    --hash=sha256:f486f402f6f9abee5bb032553736813af0c710a86b2e0ca592634c55cea1f835
+    # via transformers
+toml==0.10.2 \
+    --hash=sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b \
+    --hash=sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f
+    # via modal
+tqdm==4.70.1 \
+    --hash=sha256:c293e525e6fef9c20e8728fd4612df02a0aa31bb5fe91ecd93e123b1b7bffa73 \
+    --hash=sha256:cefd0eca11b2a37a3aee776544d4f4ae913f02688135b5556b8788dfa474afc4
+    # via
+    #   huggingface-hub
+    #   mlx-audio
+    #   mlx-vlm
+    #   transformers
+transformers==5.17.0 \
+    --hash=sha256:78ec1ce21579b38dfb83950a0658cd119f87212a2fcfdff478096ce9d6c03801 \
+    --hash=sha256:a153be279169b55b92d8000bf4af294aed684503d091cca7804da2dd8a9de000
+    # via
+    #   mlx-audio
+    #   mlx-vlm
+    #   solomon-mlx
+typer==0.27.2 \
+    --hash=sha256:269b7eb9d3c202ca84b4bc9618cb04ebb43d3d4d1e567e4c768607232c05f945 \
+    --hash=sha256:b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d
+    # via transformers
+types-certifi==2021.10.8.3 \
+    --hash=sha256:72cf7798d165bc0b76e1c10dd1ea3097c7063c42c21d664523b928e88b554a4f \
+    --hash=sha256:b2d1e325e69f71f7c78e5943d410e650b4707bb0ef32e4ddf3da37f54176e88a
+    # via modal
+types-toml==0.10.8.20260518 \
+    --hash=sha256:0e564ab05f6fde62a315b3b5a9b6624fda569399795d30a37e64705a70459303 \
+    --hash=sha256:80e10facd24fdeda9d5c672187d72be3ac284843788d67f5aae59e3e016db6fe
+    # via modal
+typing-extensions==4.16.0 \
+    --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \
+    --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5
+    # via
+    #   aiohttp
+    #   aiosignal
+    #   anyio
+    #   fastapi
+    #   huggingface-hub
+    #   modal
+    #   pydantic
+    #   pydantic-core
+    #   starlette
+    #   synchronicity
+    #   typing-inspection
+typing-inspection==0.4.4 \
+    --hash=sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47 \
+    --hash=sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147
+    # via
+    #   fastapi
+    #   pydantic
+urllib3==2.8.0 \
+    --hash=sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3 \
+    --hash=sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63
+    # via
+    #   botocore
+    #   requests
+uvicorn==0.53.0 \
+    --hash=sha256:a9356f0cb89b3b8621529c5d5eebd69bfe154f4c3f68b4cf2de47e45fa855c2e \
+    --hash=sha256:e8dca71ec86dce5f04e333f0d56cdedf942446e6643b9cea1af0d6d3a02cb03e
+    # via mlx-vlm
+watchfiles==1.2.0 \
+    --hash=sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9 \
+    --hash=sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98 \
+    --hash=sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f \
+    --hash=sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427 \
+    --hash=sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4 \
+    --hash=sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa \
+    --hash=sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c \
+    --hash=sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906 \
+    --hash=sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c \
+    --hash=sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c \
+    --hash=sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077 \
+    --hash=sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01 \
+    --hash=sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9 \
+    --hash=sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658 \
+    --hash=sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0 \
+    --hash=sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8 \
+    --hash=sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898 \
+    --hash=sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44 \
+    --hash=sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5 \
+    --hash=sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc \
+    --hash=sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5 \
+    --hash=sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9 \
+    --hash=sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0 \
+    --hash=sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55 \
+    --hash=sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb \
+    --hash=sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0 \
+    --hash=sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26 \
+    --hash=sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3 \
+    --hash=sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838 \
+    --hash=sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71 \
+    --hash=sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d \
+    --hash=sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44 \
+    --hash=sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2 \
+    --hash=sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5 \
+    --hash=sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799 \
+    --hash=sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379 \
+    --hash=sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925 \
+    --hash=sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72 \
+    --hash=sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08 \
+    --hash=sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4
+    # via modal
+websockets==17.1 \
+    --hash=sha256:00bf34b64501e3477e81fc281532ff3cbf4da26633c10b63979d5085d46602d3 \
+    --hash=sha256:0340bbef6bfbe16da888b3983d666a4db4954ac3253c38f13bc7aba0c7db5a2f \
+    --hash=sha256:073c5c3f7e127041fa9d34a9e29ceefee8c3cafbd267ed2927318f425144380d \
+    --hash=sha256:0c863507ada5805517ca6dff1c524dcd42942efe6304dacf06700878398d21a6 \
+    --hash=sha256:0de501b7f2db11e83739ac20e2d33d46da4604b829f506c24be80e7def069391 \
+    --hash=sha256:1fce0f43e0d41422e0b2cad6561e1970df22f212f4c7e884967df7cf591b031c \
+    --hash=sha256:29176d8b429cfa0fa443c473878d37a5c06cfd0cb36b71ba4314accc71e05906 \
+    --hash=sha256:2a0162a6372110a5601cb5c9fd826635cedf69f3e110c545dd19774e040b970e \
+    --hash=sha256:2afb58c7ba48b329d56769f8dfd89f394efe587b65ef806bae810a484d6d3608 \
+    --hash=sha256:3709a1ab30b4b922027d22f68d2b61a0656a91680ac894a537624e6be7dd7f7c \
+    --hash=sha256:4031152769179ab8dcdeafc7b0e58052a49117560a28671700b47b2c7b717aad \
+    --hash=sha256:43bd0c1ceb924d67f5c1a5254d8361dd9d94246e6331a726064dfa2917880780 \
+    --hash=sha256:581fa678ef46f4277cc8491312468e582f8ad609dbab907ba6096a08c6a0ff98 \
+    --hash=sha256:5aefe78e6a3077fe22b5e64b04666a85a3eb8b934d40e8595a693adcbceb6f11 \
+    --hash=sha256:5f051f8030a51815dc00e24bd2e5f1435af095c1cc111d747ac6e2a3620d7641 \
+    --hash=sha256:617243e19a0992095956f406ee9cd3bc4ba92862d83cb1d83bb59ce574412bec \
+    --hash=sha256:655a8e28010f09fd6fa317e857afab3af7647f33e41dee88fa421e92086d1090 \
+    --hash=sha256:677014a073bcb1fbaa7e21144786864f16c08f856d66834f611eceb9006cbab8 \
+    --hash=sha256:76dd004f59115087c7b700474cb18f01325e37250032e19396c08ae41448e4b3 \
+    --hash=sha256:77b37cceca17291897c3c73bd30a7c7c7909593554b5da574ec852af83c1742a \
+    --hash=sha256:7a72efa3bf4fa3a6669a54420a472ad056da3973d827f10e3a536da463f926c2 \
+    --hash=sha256:7e724f843fa6a0614aece65a7c73e51d0f4412ca41dccac13c3caf98e69536bb \
+    --hash=sha256:829dba1bc049779de9b332088c1a6a9858e96bd67e50b6b644a95e02b67836bc \
+    --hash=sha256:87f0d5e77548b0c40c8464cdb6108792e7e53f487c6400028a4ec28a8afbe5ab \
+    --hash=sha256:882af300d2c6a092b93767d5de03c7bb56dfb06314140c8e872d3f48e09f7b74 \
+    --hash=sha256:9f4a08ff7cb68c27b18e09223cc6304e01d0f82d5a240d251266dfd2e6e44729 \
+    --hash=sha256:9f4c0377a83e163a303514fdfab501dbe379bdc13e5b9312a91d112658b29dce \
+    --hash=sha256:a06f3b5085176763182449559e20391d7ce616a8972a9f7a33deda87ea6d4f3c \
+    --hash=sha256:acfea4c20bf54384883ea33b1240fc1db4f52e190823a4e2b334bc3e8bfca96a \
+    --hash=sha256:c3241d684a76eaaef8b2dc789afde4343cd3aad55ea81e4e8ab3605b529bae51 \
+    --hash=sha256:ccbf3f4a9890d50b3a08ee04029fde30a03bfdeffaa19977628bf17251764e60 \
+    --hash=sha256:ce0305b702b20d1e1d60a9aaace6bc89970e1753565543f310d549eab22c2435 \
+    --hash=sha256:d41ef69d5416fbc1d98cf96c37be6192d10fd101c3e0f8b3ddc36e09432b3c08 \
+    --hash=sha256:d8e83333385cac6030a5167fd18bf96cc6c58b914c308e683f05b0cf94bc8dd0 \
+    --hash=sha256:dc2b79afc074d2f3e64b26539350f697fe1b85ea1c49ea24eb588f247b053ce1 \
+    --hash=sha256:e4bd7eacb87d8cf3ed70d6392c770a0d92441f05d7d2a3efafb5bc171d5e3067 \
+    --hash=sha256:e5f5c7a893507d0e83a80b88aefd6522f7e882cd53f9722c6f23f5a020c9557c \
+    --hash=sha256:eec113a5b41d124ef42ff56b0d74a6da3fd986400038eab9e58ee42a4024e837 \
+    --hash=sha256:f221081107b8c48184d99f7019604486376e7ef826037e70aad6b02540732c23 \
+    --hash=sha256:f62114a54117e4948a1e414e89521f7fe1e3c2f83f2a571a06a4fc6718b0900a \
+    --hash=sha256:f64e001bb7fa89b9f32cfa600bf8e9ac8ca26759d9b92ae01453ee303d9cd7b4 \
+    --hash=sha256:fd8f47dbf2e8adb15c847215f83436de3fdb120b51fdae0fbbdf69fd97a3ad80
+    # via mlx-vlm
+yarl==1.25.1 \
+    --hash=sha256:03dd38de09bc213e9a8b29761eec33ee1d5318dac0e49d8af36e4d27830e23a7 \
+    --hash=sha256:0a66db89ea473abeac4b70523cafd94db3772380e565f9d28af7a179b7af71fa \
+    --hash=sha256:0f12afda4eea8c8994a76d4df1875c765194f5fbe8a9d197929ea303caee29ec \
+    --hash=sha256:10b2fd95332f0d716d5eee3c9fb2ce8eada19082de7fee83d32e37992fd75c26 \
+    --hash=sha256:126a2533570c554719ca40a1288fdee1700b6bc82e7131aa69fa85252d92e651 \
+    --hash=sha256:14b79a30a93a3ce2e8832603fd0ab780ada281b0ba5110b519a634f2d7d7d1fc \
+    --hash=sha256:1f51020b2eb8a003c84925638ec63c21a750a4bddd3a22ec8eac6a742dadf1b9 \
+    --hash=sha256:25868beca8b6765f8f7d0e11fe6dd7c66dd4b0793b9500286d20cc92352126a5 \
+    --hash=sha256:2b49375d22299b0a834c2bca72f39aaecc270d96fb24c30424899676f487b22a \
+    --hash=sha256:3feb99222553a8cbedfa52c2f59dd84c3f50d5b582c728d522caf8d72769a54b \
+    --hash=sha256:419f392a1da624877975709e3864dfe833af6cc7671b39318086d456e288380c \
+    --hash=sha256:4bd6340d20ae2c7ca719b87b426e808e90743b676d05d4c26c4fb5ca71f41184 \
+    --hash=sha256:4d781294bb815ecb5ea57ff6bbf8038e0a31a95fdf3e1788f66e0dc100d64b58 \
+    --hash=sha256:681c758b0490f9e96b78e5fa8e8dc6e648e9185bb6eaebe73183c33ea0c445f3 \
+    --hash=sha256:68782fdb4027b8d1eee25ec35e9a6db05e863b899eb0310b3a33b6c3fef55707 \
+    --hash=sha256:7d575b54cb3863ef9bc290ea4b009999d55dc237326131e4853cf33e888fee03 \
+    --hash=sha256:7e4de3ac4adbad3d0bc7c6f4360a7dbff5de2f15e3b723be3198074e17fd9c40 \
+    --hash=sha256:80e47012e730da131c9f059c80936783f9659aae22dc31c03c0595590d11ed54 \
+    --hash=sha256:83d4a37e4b95da4d8bda930d6d35b75b4cdadbacbb4980cae290ea3100b5d51d \
+    --hash=sha256:94d7aa6debf92a1dd14cb5280b083a764169a13cfb23a452111160274ed989f4 \
+    --hash=sha256:a2ed0ba415ccdf08f14bf544cb78346d0f76086707ffee24921a2c84dbf1305a \
+    --hash=sha256:a3faadac7d812ddac258feb57b9846b60c1b437c4f4b9ad42595c6f6fe4390df \
+    --hash=sha256:af4ea5b37403ef4e30f3927eaed540db942bde01d8d3ff083527c0704d1c9c68 \
+    --hash=sha256:b10dd0557ba422715b5206b3743192135a6022acca8baec51aa127d0a75db8fe \
+    --hash=sha256:bc3ac7bf569f6b64dad04dd7808c7872dae8a97df657856eac05e9b7e3614a85 \
+    --hash=sha256:be80550d9bfe83d9b62398a37081a90434e6df2d978ec345c3d2820de6beddab \
+    --hash=sha256:c6f117789d22dce188e5754e8bc65b7e6ebf8cb73963b9fa761f672a5883769d \
+    --hash=sha256:cce0727fd5ac04d372fa9bbfde9febc2bcf209aadfcf0468e45dec72719895d1 \
+    --hash=sha256:e029648f9c951db30e98a7d7ec90835db88ec4b32820efe2a9bdc2287e032eb6 \
+    --hash=sha256:e07595c7d6f4db270ceede356a1bd1c07a34f1c26f958d1ed0cd7b48e0d2bba3 \
+    --hash=sha256:e12c538e00e7c1b286a07061046b90e8124e6a9793efae2c70db6a4aad07faad \
+    --hash=sha256:e546fe1d4a93ebc2910f0d768baff19faa09843ab3f2036a67ed6e69fae4419d \
+    --hash=sha256:e80f557716fd765439577131e526b8942ffc2c07bdbc5e39fa62f660ba1e963f \
+    --hash=sha256:eb96ed1ae6c7d072d60840c0434aef07a2df611812810807fbc54263a6053e9a \
+    --hash=sha256:ef74070ac553c59eb4f04258722066d6c6135b7baa03b2e9f2da65c096e96d98 \
+    --hash=sha256:f61964f235a43738bfac50da46fc4254943a7eea3051aeb0b6fc7c992c29fadc
+    # via aiohttp

mlx/requirements.lock

@@ -0,0 +1,79 @@
+aiohappyeyeballs==2.7.1
+aiohttp==3.14.3
+aiosignal==1.4.0
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anyio==4.15.1
+attrs==26.1.0
+cbor2==6.1.4
+certifi==2026.7.22
+cffi==2.1.1
+charset-normalizer==3.5.1
+click==8.5.0
+fastapi==0.141.1
+filelock==4.0.1
+frozenlist==1.8.0
+fsspec==2026.9.0
+grpclib==0.4.9
+h11==0.16.0
+h2==4.4.1
+hf-xet==1.6.0
+hpack==4.2.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==1.32.0
+hyperframe==6.1.0
+idna==3.20
+iniconfig==2.3.0
+jinja2==3.1.6
+llguidance==1.8.0
+markdown-it-py==4.2.0
+markupsafe==3.0.3
+mdurl==0.1.2
+miniaudio==1.71
+mlx==0.32.2
+mlx-audio==0.5.4
+mlx-metal==0.32.2
+mlx-vlm==0.7.1
+modal==1.5.5
+multidict==6.9.0
+numpy==2.5.3
+opencv-python==5.0.0.93
+packaging==26.3
+pillow==12.3.0
+pluggy==1.6.0
+propcache==0.5.4
+protobuf==6.33.6
+pycparser==3.0
+pydantic==2.13.5
+pydantic-core==2.46.5
+pygments==2.21.0
+pytest==9.1.1
+python-multipart==0.0.32
+pyyaml==6.0.3
+regex==2026.9.10
+requests==2.34.2
+rich==15.0.0
+ruff==0.16.8
+safetensors==0.8.0
+scipy==1.18.1
+sentencepiece==0.2.2
+shellingham==1.5.4
+-e .
+sounddevice==0.5.6
+starlette==1.6.0
+synchronicity==0.12.5
+tokenizers==0.23.2
+toml==0.10.2
+tqdm==4.70.1
+transformers==5.17.0
+typer==0.27.2
+types-certifi==2021.10.8.3
+types-toml==0.10.8.20260518
+typing-extensions==4.16.0
+typing-inspection==0.4.4
+urllib3==2.8.0
+uvicorn==0.53.0
+watchfiles==1.2.0
+websockets==17.1
+yarl==1.25.1

mlx/scripts/benchmark.py

@@ -0,0 +1,122 @@
+"""Full-model parity and measurements on this Mac; emits no simulated hardware results."""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import mlx.core as mx
+import numpy as np
+
+from solomon_mlx import Solomon
+from solomon_mlx._vendor.semantics import listed_probs, p_yes
+from solomon_mlx.artifacts import digest, sha256
+
+
+def probabilities(job, row):
+    if job["task"] in ("boolean", "multilabel", "entity"):
+        p = p_yes(row["letter_logits"])
+        return np.array([p, 1 - p])
+    n = job["n"] - 2 if job["head_key"].endswith("choiceR") else job["n"]
+    return listed_probs(row["letter_logits"], n)
+
+
+def run(model_dir, jobs_path, reference_path, output):
+    output = Path(output)
+    if output.exists():
+        raise FileExistsError("Benchmark outputs are immutable")
+    jobs = json.loads(Path(jobs_path).read_text())
+    reference = json.loads(Path(reference_path).read_text())
+    ref = {r["id"]: r for r in reference["rows"]}
+    if set(ref) != {j["id"] for j in jobs}:
+        raise ValueError("Benchmark and reference jobs differ")
+    mx.reset_peak_memory()
+    started = time.perf_counter()
+    model = Solomon.load(model_dir)
+    load_seconds = time.perf_counter() - started
+    states = {}
+    rows = []
+    prefills = []
+    try:
+        for job in jobs:
+            key = digest(job["parts"])
+            if key not in states:
+                state = model.prefill(job["parts"])
+                states[key] = state
+                prefills.append(
+                    {
+                        "document": key,
+                        "tokens": state.prefix_tokens,
+                        "seconds": state._data["prefill_seconds"],
+                        "vision_seconds": state._data["vision_seconds"],
+                        "cache_bytes": sum(c.nbytes for c in state._data["cache"]),
+                    }
+                )
+            state = states[key]
+            row = model.engine.ask(
+                state._data,
+                job["block"],
+                job["n"],
+                job["head_key"],
+                execution=job.get("execution", "cached"),
+                taps=job.get("taps", []),
+            )
+            p, q = probabilities(job, row), probabilities(job, ref[job["id"]])
+            row.update(
+                id=job["id"],
+                decision_agrees=bool(p.argmax() == q.argmax()),
+                max_probability_drift=float(np.max(np.abs(p - q))),
+                max_logit_drift=float(
+                    np.max(np.abs(np.array(row["letter_logits"]) - ref[job["id"]]["letter_logits"]))
+                ),
+                prefix_ids_exact=state._data["prefix_ids"] == ref[job["id"]]["prefix_ids"],
+            )
+            if "token_ids" in row:
+                row["token_ids_exact"] = row["token_ids"] == ref[job["id"]]["token_ids"]
+            if row.get("taps"):
+                row["layer_max_hidden_drift"] = {
+                    k: float(np.max(np.abs(np.array(v) - ref[job["id"]]["taps"][k])))
+                    for k, v in row["taps"].items()
+                }
+            rows.append(row)
+            print(job["id"], row["seconds"], row["decision_agrees"], flush=True)
+        # Replay checks real prefill and repeated question semantics on the same binding.
+        first = states[digest(jobs[0]["parts"])]
+        recipe = output.with_suffix(".replay.json")
+        first.save(recipe)
+        with model.replay(recipe) as restored:
+            b, n, h = jobs[0]["block"], jobs[0]["n"], jobs[0]["head_key"]
+            replay = model.engine.ask(restored._data, b, n, h)
+            replay_drift = float(np.max(np.abs(np.array(replay["letter_logits"]) - rows[0]["letter_logits"])))
+    finally:
+        for state in states.values():
+            state.close()
+    warm = [r["seconds"] for r in rows if r["reused_prefix_tokens"]]
+    report = {
+        "runtime": model.identity,
+        "device": mx.device_info(),
+        "jobs_sha256": sha256(jobs_path),
+        "reference_sha256": sha256(reference_path),
+        "load_seconds": load_seconds,
+        "prefills": prefills,
+        "rows": rows,
+        "warm_question_latency_median_seconds": float(np.median(warm)),
+        "questions_per_second": len(warm) / sum(warm),
+        "peak_metal_bytes": mx.get_peak_memory(),
+        "replay_max_logit_drift": replay_drift,
+        "decision_agreement": float(np.mean([r["decision_agrees"] for r in rows])),
+        "scope": "development parity fixtures; not held-out task accuracy or release qualification",
+        "calibration_status": "uncalibrated",
+    }
+    output.write_text(json.dumps(report, indent=2))
+    return report
+
+
+if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    p.add_argument("--model", default="models/quality")
+    p.add_argument("--jobs", default="evaluations/golden-jobs.json")
+    p.add_argument("--reference", default="evaluations/bf16-reference-1789901869/report.json")
+    p.add_argument("--output", default="evaluations/bf16-text-benchmark.json")
+    a = p.parse_args()
+    run(a.model, a.jobs, a.reference, a.output)

mlx/scripts/benchmark_chunks.py

@@ -0,0 +1,50 @@
+"""Measure 512/1024/2048-token prefill on frozen original acceptance documents."""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import mlx.core as mx
+
+from solomon_mlx import Solomon
+
+p = argparse.ArgumentParser()
+p.add_argument("--model", default="models/quality")
+p.add_argument("--output", default="evaluations/chunk-benchmark.json")
+a = p.parse_args()
+out = Path(a.output)
+if out.exists():
+    raise FileExistsError("Use a new immutable benchmark output")
+model = Solomon.load(a.model)
+fixtures = json.loads(Path("evaluations/cuda-acceptance/input/documents.json").read_text())
+results = []
+for document, parts in fixtures["documents"].items():
+    for target in (1242, 2048):
+        text = "".join(p["text"] for p in parts)
+        while True:
+            rendered = model.engine.render([{"text": text}], "X")
+            end = rendered.rfind("\n\nX")
+            length = len(model.engine.t.encode(rendered[:end], add_special_tokens=False)) - 1
+            if length >= target:
+                break
+            text += fixtures["filler"]
+        for chunk in (512, 1024, 2048):
+            model.engine.chunk_size = chunk
+            mx.reset_peak_memory()
+            started = time.perf_counter()
+            with model.prefill(text) as state:
+                results.append(
+                    {
+                        "document": document,
+                        "chunk": chunk,
+                        "tokens": state.prefix_tokens,
+                        "seconds": time.perf_counter() - started,
+                        "peak_metal_bytes": mx.get_peak_memory(),
+                        "cache_bytes": sum(c.nbytes for c in state._data["cache"]),
+                    }
+                )
+            print(results[-1], flush=True)
+out.write_text(
+    json.dumps({"runtime": model.identity, "measurements": results, "hardware_simulation": False}, indent=2)
+)

mlx/scripts/check_cuda_parity.py

@@ -0,0 +1,172 @@
+"""Compare saved MLX scores with CUDA using identical, frozen temperatures.
+
+No fitting, parameter selection, or changes to inference weights take place.
+Partial panels are diagnostic only and can never qualify a release.
+"""
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+
+from solomon_mlx._vendor.semantics import listed_probs, p_yes
+from solomon_mlx.api import TASKS
+from solomon_mlx.artifacts import digest, runtime_identity, sha256
+from solomon_mlx.evaluation import compare_rows, load_panel, read_cuda_scores
+
+
+def decision_probabilities(row, temperature):
+    """Parity includes every branch, even when its gold label is not a listed option."""
+    if row["task"] in ("boolean", "entity", "multilabel"):
+        p = p_yes(row["letter_logits"], temperature)
+        return np.array([1 - p, p])
+    width = row["n"] - 2 if row["head_key"].endswith("choiceR") else row["n"]
+    return listed_probs(row["letter_logits"], width, temperature)
+
+
+def compare(panel, scores, cuda_directory, reference, output, *, allow_partial=False):
+    panel, scores, output = Path(panel), Path(scores), Path(output)
+    if output.exists():
+        raise FileExistsError("Parity reports are immutable")
+    jobs, manifest = load_panel(panel)
+    identity = json.loads((scores / "identity.json").read_text())
+    model_binding = json.loads(Path("models/quality/binding.json").read_text())
+    if identity["runtime"] != runtime_identity(model_binding):
+        raise ValueError("Scores belong to another MLX runtime")
+    if identity["panel_sha256"] != manifest["jobs_sha256"]:
+        raise ValueError("Scores belong to another panel")
+    groups = defaultdict(list)
+    for job in jobs:
+        groups[job["document_key"]].append(job)
+    rows, files = [], {}
+    for key, group in groups.items():
+        path = scores / (key + ".json")
+        if not path.exists() and allow_partial:
+            continue
+        record = json.loads(path.read_text())
+        body = {k: v for k, v in record.items() if k != "sha256"}
+        if (
+            record["sha256"] != digest(body)
+            or record["identity"] != digest(identity)
+            or [r["id"] for r in record["rows"]] != [r["id"] for r in group]
+        ):
+            raise ValueError("Corrupt or mismatched score document")
+        rows.extend(record["rows"])
+        files[path.name] = sha256(path)
+    complete = len(files) == len(groups)
+    if not allow_partial:
+        marker = json.loads((scores / "complete.json").read_text())
+        if marker != {
+            "identity": digest(identity),
+            "documents": len(groups),
+            "branches": len(jobs),
+            "files": files,
+        }:
+            raise ValueError("Incomplete or mismatched completion manifest")
+    ref = json.loads(Path(reference).read_text())
+    cuda = read_cuda_scores(cuda_directory, panel, ref["identity"])
+    selected = {r["id"] for r in rows}
+    cuda = [r for r in cuda if r["id"] in selected]
+    binding_path = Path("evaluations/cuda-acceptance/input/serving-binding.json")
+    source_manifest = json.loads((binding_path.parent / "manifest.json").read_text())
+    if sha256(binding_path) != source_manifest["files"][binding_path.name]:
+        raise ValueError("CUDA acceptance binding checksum mismatch")
+    binding = json.loads(binding_path.read_text())
+    for key in (
+        "adapter_sha256",
+        "trained_heads_sha256",
+        "model_sha256",
+        "numerics",
+        "placement",
+        "arithmetic",
+    ):
+        if binding["runtime"][key] != ref["identity"][key]:
+            raise ValueError("CUDA temperatures belong to another reference")
+    temperatures = {task: binding["temperatures"]["models"][task]["temperature"] for task in TASKS}
+    comparisons = {}
+    cuda_by_id = {r["id"]: r for r in cuda}
+    for name, temps in (("temperature_one", dict.fromkeys(TASKS, 1.0)), ("cuda_serving", temperatures)):
+        result = compare_rows(rows, cuda, temperatures=temps, reference_temperatures=temps)
+        result.pop("quality_gate_passed")
+        result["accuracy_units"] = result["units"]
+        result["accuracy_questions"] = result["questions"]
+        worst, questions = [], defaultdict(list)
+        for row in rows:
+            other = {**row, "letter_logits": cuda_by_id[row["id"]]["letter_logits"]}
+            p = decision_probabilities(row, temps[row["task"]])
+            q = decision_probabilities(other, temps[row["task"]])
+            if not np.isfinite(p).all() or not np.isfinite(q).all():
+                raise ValueError("Nonfinite parity probability")
+            agrees = int(np.argmax(p)) == int(np.argmax(q))
+            questions[row["question_id"]].append(agrees)
+            worst.append(
+                {
+                    "id": row["id"],
+                    "task": row["task"],
+                    "max_probability_drift": float(np.max(np.abs(p - q))),
+                    "decision_agrees": agrees,
+                }
+            )
+        result.update(
+            units=len(rows),
+            questions=len(questions),
+            unit_decision_agreement=float(np.mean([r["decision_agrees"] for r in worst])),
+            question_decision_agreement=float(np.mean([all(v) for v in questions.values()])),
+            max_probability_drift=max(r["max_probability_drift"] for r in worst),
+            mean_probability_drift=float(np.mean([r["max_probability_drift"] for r in worst])),
+        )
+        result["agreement_gate_passed"] = (
+            result["unit_decision_agreement"] >= 0.999 and result["question_decision_agreement"] >= 0.999
+        )
+        result["largest_probability_differences"] = sorted(
+            worst, key=lambda r: r["max_probability_drift"], reverse=True
+        )[:10]
+        comparisons[name] = result
+    report = {
+        "scope": "complete text parity panel" if complete else "partial text parity diagnostic",
+        "complete": complete,
+        "documents": len(files),
+        "total_documents": len(groups),
+        "branches": len(rows),
+        "total_branches": len(jobs),
+        "tasks": sorted({r["task"] for r in rows}),
+        "runtime": identity["runtime"],
+        "cuda_runtime": ref["identity"],
+        "panel_sha256": identity["panel_sha256"],
+        "score_files_sha256": digest(files),
+        "cuda_serving_binding_sha256": sha256(binding_path),
+        "temperature_fitting_performed": False,
+        "temperature_policy": "identical settings on both backends; not MLX calibration",
+        "comparisons": comparisons,
+        "parity_gate_passed": complete and all(r["agreement_gate_passed"] for r in comparisons.values()),
+        "bitwise_equality_claimed": False,
+        "image_qualification": False,
+    }
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(report, indent=2))
+    print(
+        json.dumps(
+            {k: report[k] for k in ("scope", "documents", "branches", "tasks", "parity_gate_passed")},
+            indent=2,
+        )
+    )
+    return report
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    for field in ("panel", "scores", "cuda-directory", "output"):
+        parser.add_argument("--" + field, required=True)
+    parser.add_argument("--reference", default="evaluations/bf16-reference-1789901869/report.json")
+    parser.add_argument("--allow-partial", action="store_true")
+    args = parser.parse_args()
+    compare(
+        args.panel,
+        args.scores,
+        args.cuda_directory,
+        args.reference,
+        args.output,
+        allow_partial=args.allow_partial,
+    )

mlx/scripts/score_parity.py

@@ -0,0 +1,19 @@
+"""Score a frozen panel for CUDA parity without fitting temperatures."""
+
+import argparse
+
+from solomon_mlx import Solomon
+from solomon_mlx.evaluation import score_panel
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", default="models/quality")
+    parser.add_argument("--panel", required=True)
+    parser.add_argument("--output", required=True)
+    args = parser.parse_args()
+    score_panel(Solomon.load(args.model), args.panel, args.output)
+
+
+if __name__ == "__main__":
+    main()

mlx/scripts/validate_api.py

@@ -0,0 +1,128 @@
+"""Focused public API checks using the real BF16 model, without calibration."""
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+from solomon_mlx import Solomon
+
+
+def validate(output):
+    output = Path(output)
+    if output.exists():
+        raise FileExistsError("Validation outputs are immutable")
+    model = Solomon.load("models/quality")
+    document = "Alice is certified. Bob is not certified. The current priority is high."
+    questions = {
+        "boolean": "Is Alice certified?",
+        "single": {"type": "choice", "instructions": "Who is certified?", "options": ["Alice", "Bob"]},
+        "ordered": {"type": "score", "instructions": "What is the priority?", "levels": ["low", "high"]},
+        "entity": {"instructions": "Is {candidate} certified?", "candidates": ["Alice", "Bob"]},
+        "multilabel": {
+            "instructions": "Which facts apply?",
+            "candidates": ["Alice is certified", "Bob is certified"],
+        },
+    }
+    checks = {}
+    with model.prefill(document) as state:
+        first = model.decide(state=state, questions=questions, evidence="none", diagnostics=True)
+        assert set(first["answers"]) == set(questions)
+        checks["all_five_answer_types"] = True
+        repeated = model.decide(
+            state=state, questions={"boolean": questions["boolean"]}, evidence="none", diagnostics=True
+        )
+        a = first["answers"]["boolean"]["branches"][0]["letter_logits"]
+        b = repeated["answers"]["boolean"]["branches"][0]["letter_logits"]
+        np.testing.assert_array_equal(a, b)
+        checks["repeated_question_logits_exact"] = True
+        full = model.decide(
+            state=state,
+            questions={"boolean": questions["boolean"]},
+            evidence="none",
+            execution="full",
+            diagnostics=True,
+        )
+        c = full["answers"]["boolean"]["branches"][0]["letter_logits"]
+        checks["cached_full_max_logit_drift"] = float(np.max(np.abs(np.array(a) - c)))
+        assert (first["answers"]["boolean"]["noul"] >= 0.5) == (full["answers"]["boolean"]["noul"] >= 0.5)
+        reverse = model.decide(
+            state=state,
+            questions={"entity": {**questions["entity"], "candidates": ["Bob", "Alice"]}},
+            evidence="none",
+        )
+        assert reverse["answers"]["entity"]["candidates"] == first["answers"]["entity"]["candidates"]
+        assert list(reverse["answers"]["entity"]["candidates"]) == ["Bob", "Alice"]
+        checks["candidate_order_and_cache_isolation"] = True
+        evidence = model.decide(state=state, questions={"boolean": questions["boolean"]}, evidence="removal")
+        answer = evidence["answers"]["boolean"]
+        assert answer["evidence"]
+        for span in answer["evidence"]:
+            assert document[span["start"] : span["end"]] == span["text"]
+        assert answer["evidence_detail"]["verification"] == "fresh_source_reencoding"
+        assert answer["evidence_detail"]["calls"] == 2
+        checks["evidence_spans_and_fresh_verification"] = True
+        exhausted = model.decide(
+            state=state, questions={"boolean": questions["boolean"]}, evidence="removal", evidence_max_calls=0
+        )
+        assert exhausted["answers"]["boolean"]["evidence_status"] == "budget_exhausted"
+        assert exhausted["usage"]["evidence_calls"] == 0
+        checks["evidence_budget_enforced"] = True
+        replay = output.with_suffix(".replay.json")
+        state.save(replay)
+    try:
+        model.decide(state=state, questions={"q": "Fact?"})
+    except ValueError:
+        checks["closed_state_rejected"] = True
+    else:
+        raise AssertionError("Closed state accepted")
+    with model.replay(replay) as restored:
+        result = model.decide(
+            state=restored, questions={"boolean": questions["boolean"]}, evidence="none", diagnostics=True
+        )
+        np.testing.assert_array_equal(a, result["answers"]["boolean"]["branches"][0]["letter_logits"])
+        checks["public_api_replay_exact"] = True
+    corrupt = json.loads(replay.read_text())
+    corrupt["parts"][0]["text"] += " changed"
+    bad_path = output.with_suffix(".corrupt-replay.json")
+    bad_path.write_text(json.dumps(corrupt))
+    try:
+        model.replay(bad_path)
+    except ValueError:
+        checks["corrupt_replay_rejected"] = True
+    else:
+        raise AssertionError("Corrupt replay accepted")
+    image_parts = json.loads(Path("evaluations/image-jobs.json").read_text())[0]["parts"]
+    with model.prefill(image_parts) as images:
+        result = model.decide(state=images, questions={"q": "Is Alice certified?"}, evidence="support")
+        assert result["answers"]["q"]["evidence_status"] == "unsupported_page_selector"
+        checks["missing_page_selector_reported"] = True
+    with model.prefill({"subject": "Alice", "certified": True}) as structured:
+        assert structured.prefix_tokens > 0
+        checks["structured_document_accepted"] = True
+    try:
+        model.engine.admit(40961)
+    except ValueError:
+        checks["context_ceiling_enforced"] = True
+    else:
+        raise AssertionError("Context limit not enforced")
+    assert model.engine.context["start"] is None
+    assert len(model.engine.heads) == 10
+    checks["adapter_state_reset_and_ten_heads_loaded"] = True
+    report = {
+        "runtime": model.identity,
+        "checks": checks,
+        "passed": True,
+        "scope": "real-weight API behavior; these checks do not establish held-out CUDA parity",
+        "answers": first["answers"],
+        "evidence": answer,
+    }
+    output.write_text(json.dumps(report, indent=2))
+    print(json.dumps({"passed": True, "checks": checks}, indent=2))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", required=True)
+    validate(parser.parse_args().output)

mlx/src/solomon_mlx/__init__.py

@@ -0,0 +1,5 @@
+"""Solomon semantic decisions on Apple Silicon."""
+
+from .api import DocumentState, Solomon
+
+__all__ = ["DocumentState", "Solomon"]

mlx/src/solomon_mlx/_vendor/__init__.py

@@ -0,0 +1,2 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.

mlx/src/solomon_mlx/_vendor/contract.py

@@ -0,0 +1,111 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.
+import json
+import numpy as np
+MAX_CANDIDATES = 64
+
+def _text(value, name):
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(name + ' must be a nonempty string')
+    return value
+
+def parse_questions(questions):
+    """Questions {id: spec} -> ordered list of normalised specs.
+
+    noul:   {"type": "noul", "instructions": str}                                   -> task boolean
+            {"type": "noul", "instructions": "Is {candidate} ...?", "candidates": [...]} -> task entity (one Noul per candidate)
+            {"type": "noul", "instructions": str, "candidates": [...], "candidate_kind": "label"} -> task multilabel
+            (candidate_kind defaults to 'entity' when instructions contain {candidate}, else 'label')
+    choice: {"type": "choice", "instructions": str, "options": [str, ...] | {key: text}, "ordered": bool}
+            ('criteria' is accepted as a compatibility alias of 'options')
+    score:  {"type": "score", "instructions": str, "levels": [str, ...]} (alias 'criteria'); an ordered choice keyed
+            "0".."K-1" with a legend and score = sum_i i * p_i.
+    """
+    if not isinstance(questions, dict) or not questions:
+        raise ValueError('questions must be a nonempty mapping of id -> question')
+    out = []
+    for qid, spec in questions.items():
+        if not isinstance(qid, str) or not qid:
+            raise ValueError('question ids must be nonempty strings')
+        if isinstance(spec, str):
+            spec = {'type': 'noul', 'instructions': spec}
+        if not isinstance(spec, dict):
+            raise ValueError(f'question {qid}: spec must be an object')
+        kind = str(spec.get('type', 'noul')).lower()
+        instructions = _text(spec.get('instructions', spec.get('question')), f'question {qid}: instructions')
+        if kind == 'noul':
+            if 'candidates' not in spec:
+                out.append({'id': qid, 'type': 'noul', 'task': 'boolean', 'request': {'question': instructions}})
+                continue
+            candidates = spec['candidates']
+            if not isinstance(candidates, list) or not 1 <= len(candidates) <= MAX_CANDIDATES or len(set(candidates)) != len(candidates) or any((not isinstance(c, str) or not c.strip() for c in candidates)):
+                raise ValueError(f'question {qid}: candidates must be 1 to {MAX_CANDIDATES} distinct nonempty strings')
+            ckind = spec.get('candidate_kind', 'entity' if '{candidate}' in instructions else 'label')
+            if ckind == 'entity':
+                if instructions.count('{candidate}') != 1 or '{entity}' in instructions:
+                    raise ValueError(f'question {qid}: entity instructions need exactly one {{candidate}} placeholder')
+                request = {'template': instructions.replace('{candidate}', '{entity}'), 'entities': list(candidates)}
+                task = 'entity'
+            elif ckind == 'label':
+                if '{candidate}' in instructions:
+                    raise ValueError(f'question {qid}: label candidates take no {{candidate}} placeholder')
+                request = {'question': instructions, 'labels': list(candidates)}
+                task = 'multilabel'
+            else:
+                raise ValueError(f'question {qid}: candidate_kind must be entity or label')
+            out.append({'id': qid, 'type': 'noul', 'task': task, 'candidates': list(candidates), 'request': request})
+        elif kind in ('choice', 'score'):
+            raw = spec.get('levels', spec.get('options', spec.get('criteria'))) if kind == 'score' else spec.get('options', spec.get('criteria'))
+            if isinstance(raw, dict):
+                keys, texts = ([str(k) for k in raw], [raw[k] if isinstance(raw[k], str) and raw[k].strip() else str(k) for k in raw])
+            elif isinstance(raw, list):
+                texts = list(raw)
+                keys = [str(i) for i in range(len(raw))] if kind == 'score' else list(raw)
+            else:
+                raise ValueError(f'question {qid}: options must be a list or a mapping')
+            if not 2 <= len(texts) <= 8 or any((not isinstance(t, str) or not t.strip() for t in texts)) or len(set(texts)) != len(texts):
+                raise ValueError(f'question {qid}: provide 2 to 8 distinct nonempty options')
+            ordered = kind == 'score' or bool(spec.get('ordered', False))
+            if not isinstance(spec.get('ordered', False), bool):
+                raise ValueError(f'question {qid}: ordered must be Boolean')
+            out.append({'id': qid, 'type': kind, 'task': 'ordered' if ordered else 'single', 'keys': keys, 'texts': texts, 'request': {'question': instructions, 'options': texts}})
+        else:
+            raise ValueError(f'question {qid}: type must be noul, choice or score')
+    return out
+
+def _state_parts(state):
+    if isinstance(state, str):
+        return [{'text': state}]
+    if isinstance(state, list):
+        return state
+    if isinstance(state, dict):
+        return [{'text': json.dumps(state, ensure_ascii=False, indent=2, sort_keys=False)}]
+    raise ValueError('state must be text, an object, or a list of document parts')
+def empty(spec):
+    if spec['type'] == 'noul':
+        return {'candidates': None} if 'candidates' in spec else {'noul': None}
+    return {'probabilities': None, 'answer': None}
+
+def present(spec, dists):
+    if spec['type'] == 'noul':
+        if 'candidates' in spec:
+            return {'candidate_kind': 'entity' if spec['task'] == 'entity' else 'label', 'candidates': {c: float(d[0]) for c, d in zip(spec['candidates'], dists)}, 'candidate_ordering_scores': {c: float(max(d[0], 1 - d[0])) for c, d in zip(spec['candidates'], dists)}}
+        return {'noul': float(dists[0][0])}
+    p = dists[0]
+    keys = spec['keys']
+    out = {'probabilities': {k: float(v) for k, v in zip(keys, p)}, 'answer': keys[int(np.argmax(p))]}
+    out['choice'] = out['answer']
+    if spec['type'] == 'score':
+        out['score'] = float(np.dot(np.arange(len(p)), p))
+        out['legend'] = dict(zip(keys, spec['texts']))
+    elif spec['task'] == 'ordered':
+        out['ordered'] = True
+    return out
+
+def decision(spec, shown):
+    if spec['type'] == 'noul':
+        if 'candidates' in spec:
+            return {c: p >= 0.5 for c, p in shown['candidates'].items()}
+        return shown['noul'] >= 0.5
+    return shown['answer']
+

mlx/src/solomon_mlx/_vendor/evidence.py

@@ -0,0 +1,156 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.
+"""Deterministic source references and explicit evidence interventions.
+
+Offsets count Python Unicode code points, never bytes. Candidate ranking is lexical
+and is labelled as such; only an independent model callback supplies support scores.
+Interventions re-encode edited source; an existing KV state cannot prove removal.
+"""
+import hashlib
+import re
+from pathlib import Path
+
+
+def digest(text):
+    return hashlib.sha256(text.encode()).hexdigest()
+
+
+def passages(text, max_chars=1200):
+    if not isinstance(text,str) or max_chars < 1:
+        raise ValueError('text and positive passage size required')
+    result=[]
+    # Cover every character, including whitespace; splitting does not normalize text.
+    start=0
+    while start < len(text):
+        limit=min(len(text),start+max_chars)
+        end=limit
+        if limit < len(text):
+            candidates=[m.end() for m in re.finditer(r'\n\s*\n|(?<=[.!?])\s+',text[start:limit])]
+            if candidates and candidates[-1] >= max_chars//2:end=start+candidates[-1]
+        result.append({'id':f'text:{start}:{end}','kind':'text','start':start,'end':end,
+                       'text':text[start:end],'source_sha256':digest(text)})
+        start=end
+    return result
+
+
+def image_pages(paths):
+    return [{'id':f'page:{i+1}','kind':'image','page':i+1,'path':str(p),
+             'source_sha256':hashlib.sha256(Path(p).read_bytes()).hexdigest()} for i,p in enumerate(paths)]
+
+
+def validate_spans(text, spans):
+    ordered=sorted(spans,key=lambda s:(s['start'],s['end']))
+    last=0
+    for span in ordered:
+        start,end=span['start'],span['end']
+        if type(start) is not int or type(end) is not int or not 0<=start<end<=len(text) or start<last:
+            raise ValueError('invalid or overlapping evidence range')
+        if span.get('source_sha256',digest(text))!=digest(text) or span.get('text',text[start:end])!=text[start:end]:
+            raise ValueError('evidence no longer matches source')
+        last=end
+    return ordered
+
+
+def rank_candidates(question, candidates, limit=8):
+    if limit<1:raise ValueError('positive candidate limit required')
+    tokens=set(re.findall(r'\w+',question.casefold()))
+    ranked=[]
+    for c in candidates:
+        words=set(re.findall(r'\w+',c.get('text','').casefold()))
+        ranked.append({**c,'candidate_score':len(words&tokens)/max(1,len(tokens)),
+                       'candidate_method':'lexical_overlap' if c['kind']=='text' else 'page_order'})
+    # Stable ties retain source order (page 2 must precede page 10).
+    return sorted(ranked,key=lambda c:-c['candidate_score'])[:limit]
+
+
+def select(question, candidates, support_score, limit=8, minimum_support=.5):
+    """Callback receives only question+candidate, never benchmark gold."""
+    if not 0<=minimum_support<=1:raise ValueError('invalid support threshold')
+    results=[]
+    for candidate in rank_candidates(question,candidates,limit):
+        score=float(support_score(question,candidate))
+        if not 0<=score<=1:raise ValueError('finite support probability required')
+        results.append({**candidate,'support_score':score})
+    chosen=[r for r in results if r['support_score']>=minimum_support]
+    return {'evidence':chosen,'candidates':results,'verification':'model_support_only',
+            'faithfulness_established':False,'no_support_found':not chosen}
+
+
+def intervene(text, spans, question, decide):
+    """decide(document,question) must prefill each supplied document afresh.
+
+    All three actual calls are returned; agreement/disagreement is evidence, not a
+    guarantee that a passage is the unique cause of an answer.
+    """
+    spans=validate_spans(text,spans)
+    evidence='\n\n'.join(text[s['start']:s['end']] for s in spans)
+    pieces=[];start=0
+    for span in spans:
+        pieces.append(text[start:span['start']]);start=span['end']
+    pieces.append(text[start:]);removed=''.join(pieces)
+    full=decide(text,question)
+    only=decide(evidence,question)
+    removal=decide(removed,question)
+    return {'full':full,'evidence_only':only,'evidence_removed':removal,
+            'evidence_only_agrees':only==full,'removal_changes_answer':removal!=full,
+            'verification':'fresh_source_reencoding','source_sha256':digest(text),
+            'evidence_sha256':digest(evidence),'removed_sha256':digest(removed),
+            'calls':3,'input_characters':len(text)+len(evidence)+len(removed)}
+
+
+def validate_pages(pages, selected):
+    """Validate ordered page manifests and selected immutable references."""
+    indexed = {}
+    for expected, page in enumerate(pages, 1):
+        if page.get('kind') != 'image' or type(page.get('page')) is not int or page['page'] != expected:
+            raise ValueError('image manifest must use consecutive source page IDs')
+        if page.get('id') != f'page:{expected}':
+            raise ValueError('image page ID does not match source position')
+        actual = hashlib.sha256(Path(page['path']).read_bytes()).hexdigest()
+        if page.get('source_sha256') != actual:
+            raise ValueError('image no longer matches source')
+        indexed[expected] = page
+    ids = []
+    for reference in selected:
+        number = reference.get('page')
+        if type(number) is not int or number not in indexed or number in ids:
+            raise ValueError('invalid or duplicate evidence page')
+        source = indexed[number]
+        if any(reference.get(key) != source[key] for key in ('id', 'kind', 'path', 'source_sha256')):
+            raise ValueError('evidence page no longer matches source manifest')
+        ids.append(number)
+    return [indexed[number] for number in sorted(ids)]
+
+
+def intervene_pages(pages, selected, question, decide, text=''):
+    """Re-encode full, evidence-only and page-removed multimodal documents.
+
+    decide(text, image_paths, question) must create a fresh state each time and
+    accept an empty image list. Evidence-only has no accompanying source text;
+    removal retains all source text and unselected pages. This isolates page
+    evidence and makes text-only sufficiency a visible competing explanation.
+    Original page IDs are recorded because subset images are renumbered on input.
+    """
+    if not isinstance(text, str):
+        raise ValueError('source text must be a string')
+    selected = validate_pages(pages, selected)
+    selected_ids = {p['page'] for p in selected}
+    removed = [p for p in pages if p['page'] not in selected_ids]
+    calls = [(text, pages), ('', selected), (text, removed)]
+    answers = []
+    for source_text, source_pages in calls:
+        # Recheck all originals before each call: never silently mix revisions.
+        validate_pages(pages, selected)
+        answers.append(decide(source_text, [p['path'] for p in source_pages], question))
+        validate_pages(pages, selected)
+    full, only, removal = answers
+    return {'full': full, 'evidence_only': only, 'evidence_removed': removal,
+            'evidence_only_agrees': only == full, 'removal_changes_answer': removal != full,
+            'verification': 'fresh_source_reencoding', 'faithfulness_established': False,
+            'source_text_sha256': digest(text),
+            'source_pages': [{k: p[k] for k in ('id', 'page', 'source_sha256')} for p in pages],
+            'evidence_page_ids': [p['page'] for p in selected],
+            'removed_input_page_ids': [p['page'] for p in removed],
+            'calls': 3, 'input_images': sum(len(p) for _, p in calls),
+            'input_image_bytes': sum(Path(p['path']).stat().st_size for _, ps in calls for p in ps),
+            'input_characters': 2 * len(text)}

mlx/src/solomon_mlx/_vendor/evidence_v3.py

@@ -0,0 +1,425 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.
+"""Evidence packages (v3): selected spans plus source-derived governing context, per question unit.
+
+A package is a genuine subset of one source document: every range is an exact, validated slice
+of the source (Python code-point offsets), rendered in source order with whitespace-only
+separators. Nothing is paraphrased, summarised or generated. Context is attached by
+question-independent document structure plus the unit's own selected spans and question text;
+gold/authoring data is never an input.
+
+Roles
+  evidence  spans chosen by the selector (or, in oracle diagnostics, gold anchors). Span
+            precision/recall gates are computed on these only, exactly as before.
+  context   ranges attached automatically, each with one or more reasons:
+    header          document title block (identity of the source, author/compiler, date)
+    interpretation  generic reading rules (scope6.retrieval.governing_context, unchanged regex)
+    locator         container of an included span: message header line (date, author ->
+                    recipient), minute number + heading, schedule/section heading, entry number
+    correction      a withdrawal/rescission/deletion elsewhere that refers to the container of an
+                    included statement and names the same subject and topic (or the exact entry)
+    withdrawn       the statement(s) that an included withdrawal refers to, so the chain is
+                    readable (the withdrawn text is marked by the withdrawal, not by us)
+    rule            a general rule / band scale whose operative topic matches the unit question
+                    (attached only when the unit has evidence)
+    exception       the exception clause governing an included rule, or the rule an included
+                    exception limits
+    definition      the sentence defining a capitalised class term used by an included rule,
+                    when it names the unit's subject
+    condition       a statement about the unit's subject that bears on an included rule's
+                    conditions or exception (>=2 shared content words beyond the question topic,
+                    or one document-rare shared word)
+    convention      the document's own reading conventions (sentences of the paragraphs that hold
+                    generic reading rules) that the package needs: silence always; conflict and vocabulary when
+                    there is evidence; removal when a withdrawal/deletion chain is present;
+                    condition when a rule is present; exception when an exception is present
+
+Size is measured as covered source characters / source characters and reported per package. A
+package above the registered cap (default 0.30) sheds context in TRIM_ORDER (never evidence, rule,
+exception, condition, correction or withdrawn context) and records what was trimmed.
+"""
+import re
+from .evidence import digest, validate_spans
+from .retrieval import candidates, governing_context
+
+SCHEMA = 'scope6-evidence-package-v3.1'
+SIZE_CAP = .30
+# Context dropped first when a package exceeds the size cap (evidence is never dropped).
+TRIM_ORDER = ('interpretation', 'convention/silence', 'convention/vocabulary', 'convention/conflict', 'header', 'definition',
+              'convention/condition', 'convention/exception', 'convention/removal', 'locator')
+MONTHS = 'January|February|March|April|May|June|July|August|September|October|November|December'
+_WORD = re.compile(r'\w+')
+_CAP = re.compile(r"\b[A-Z][\w&'-]*")
+_WITHDRAWAL = re.compile(r"withdr[ae]w|withdrawn|take back|disregard|rescind|retract|should not be relied|"
+                         r"substituted|\bis deleted|\bdelete[sd]?\b|struck out|replaced by|no further effect", re.I)
+_REF_DATE = re.compile(r'(?:message|wrote|written|letter|note)\D{0,14}?(\d{1,2} (?:' + MONTHS + r'))')
+_REF_MINUTE = re.compile(r'\bminute (\d+)\b', re.I)
+_REF_ENTRY = re.compile(r'\b[Ee]ntry (\d+) of [Ss]chedule (\d+)')
+_MSG_HEAD = re.compile(r'Message \d+\. (\d{1,2} (?:' + MONTHS + r'))\.')
+_MINUTE_HEAD = re.compile(r'(\d+)\.\s+[^.\n]{1,80}\.')
+_SCHEDULE_HEAD = re.compile(r'SCHEDULE (\d+)\b')
+_ENTRY_PREFIX = re.compile(r'[A-Z]?\d+(?:\.\d+)*\.?\s*')
+_PERMISSION = re.compile(r'\bmay\b|permitted|authorised|entitled|leave to|allowed|cleared|confers?', re.I)
+_RULE = re.compile(r"(?i:\b(?:any|each|every)\s+[a-z]+(?:\s+[a-z]+)?\s+(?:who|that)\b|\ban?\s+[a-z]+\s+who\b|general rule|standing rule|"
+                   r"office rule|rule governing|\bif that\b|where one and the same|\b[a-z]+s who\b|\bwhere (?:an?|any|one)\b)|\b[A-Z][a-z]+ [A-Z][a-z]+s? (?:that|who)\b")
+_SCALE = re.compile(r'\bbands?\b|\bscale\b|from lowest to highest|order of the levels|worked out from|fixed by that number|\bfewer than \d+', re.I)
+_EXCEPTION = re.compile(r'does not apply|confers nothing on|is outside (?:clause|the rule)|not engaged|does not reach|switched off|'
+                        r'disapplied|subject to (?:one|the) exception|nothing in the rule|save that|except (?:where|that|for)\b', re.I)
+CONVENTIONS = {
+    'removal': re.compile(r"withdr[ae]w|rescind|delet|substitut|struck out|take back|displace|disregard|\bspent\b|express(?:ly)? (?:withdrawal|rescission)", re.I),
+    'condition': re.compile(r"\bconditions?\b|\blimbs?\b|requirements?\b|only part|part of the way|whole of it|each of its|all of its", re.I),
+    'exception': re.compile(r"\bexcept", re.I),
+    'conflict': re.compile(r"both (?:stand|remain|hold|are in force|left standing)|opposite (?:ways|things)|inconsistent|contradict|"
+                           r"point opposite|not say which|not chosen between|this office does not say", re.I),
+    'vocabulary': re.compile(r"interchangeabl|one and the same (?:permission|refusal)|are one (?:grant|refusal)|mean the same|same thing|words to like effect", re.I),
+    'silence': re.compile(r"silen|absence of|unminuted|nothing has been decided|has not been said|undecided|left open", re.I)}
+_DEFINES = re.compile(r'\bare\b|\bmeans\b|\bidentified\b|\binclude', re.I)
+_STOP = {'this', 'that', 'these', 'those', 'with', 'under', 'which', 'what', 'does', 'file', 'correspondence', 'record', 'records',
+         'recorded', 'minutes', 'agreement', 'bundle', 'messages', 'message', 'stand', 'stands', 'taking', 'reading', 'whole',
+         'strength', 'position', 'open', 'given', 'have', 'been', 'applies', 'apply', 'entitled', 'allowed', 'liberty', 'free',
+         'from', 'there', 'their', 'they', 'decisions', 'here', 'schedules', 'schedule', 'papers', 'office', 'shown', 'show',
+         'shows', 'case', 'matters', 'terms', 'place', 'placed', 'about', 'question', 'whether', 'should', 'relied', 'either',
+         'wrote', 'withdraw', 'withdrawn', 'passage', 'treat', 'nothing', 'follows', 'please', 'disregard', 'concerns', 'deals',
+         'resolved', 'rescinded', 'much', 'decision', 'minute', 'further', 'effect', 'permission', 'permitted', 'refused',
+         'barred', 'prohibited', 'authorised', 'cleared', 'leave', 'allows', 'allow', 'bars', 'refuses', 'grant', 'refusal',
+         'entry', 'deleted', 'substituted', 'following', 'replaced', 'struck', 'committee', 'secretary', 'chair', 'principal'}
+ROLES = ('evidence', 'context')
+# Capitalised words that are never subject names (sentence openers, document furniture).
+_NOT_NAMES = {'the', 'this', 'that', 'these', 'those', 'it', 'its', 'i', 'we', 'our', 'my', 'on', 'for', 'so', 'as', 'at', 'in', 'of',
+              'please', 'treat', 'where', 'when', 'what', 'which', 'who', 'whether', 'any', 'each', 'every', 'no', 'nothing', 'there',
+              'message', 'messages', 'entry', 'schedule', 'clause', 'minute', 'minutes', 'agreement', 'principal', 'resolved', 'note',
+              'committee', 'secretary', 'chair', 'treasurer', 'register', 'records', 'record', 'permission', 'an', 'a', 'if', 'all',
+              'both', 'neither', 'either', 'one', 'two', 'words', 'dates', 'decisions', 'rules', 'only', 'once', 'part', 'to', 'by',
+              'read', 'do', 'what', 'should', 'with', 'from', 'under', 'after', 'before', 'reading', 'taking', 'is', 'has', 'have'}
+
+
+def _words(s):
+    return set(_WORD.findall(s.casefold()))
+
+
+def _topic(s, names=()):
+    low = {w for n in names for w in _words(n)}
+    return {w for w in _words(s) if len(w) >= 4 and w not in _STOP and w not in low and not w.isdigit()
+            and not re.fullmatch(MONTHS.casefold(), w)}
+
+
+class Structure:
+    """Question-independent source structure: sentences, paragraphs, lines and containers."""
+
+    def __init__(self, text):
+        self.text = text
+        self.sentences = candidates(text)
+        self.paragraphs = []
+        start = 0
+        for m in list(re.finditer(r'\n\s*\n', text)) + [None]:
+            end = m.start() if m else len(text)
+            if text[start:end].strip():
+                self.paragraphs.append((start, end))
+            start = m.end() if m else len(text)
+        self.lines = [(m.start(), m.end()) for m in re.finditer(r'[^\n]+', text)]
+        df = {}
+        for s in self.sentences:
+            for w in _words(s['text']):
+                df[w] = df.get(w, 0) + 1
+        self.df = df
+        self.interpretation = [(s['start'], s['end']) for s in governing_context(text, self.sentences)]
+        # containers: message date -> paragraph; minute number -> paragraph; (schedule, entry) -> line
+        self.messages, self.minutes, self.entries = {}, {}, {}
+        for a, b in self.paragraphs:
+            first = text[a:b].split('\n', 1)[0]
+            m = _MSG_HEAD.match(first)
+            if m:
+                self.messages.setdefault(m.group(1), (a, b))
+            m = re.match(r'(\d+)\. ', text[a:b])
+            if m and '\n' not in text[a:b].strip():
+                self.minutes.setdefault(m.group(1), (a, b))
+            m = _SCHEDULE_HEAD.match(first)
+            if m:
+                for la, lb in self.lines:
+                    if a <= la and lb <= b:
+                        e = re.match(r'(\d+)\. ', text[la:lb])
+                        if e:
+                            self.entries[(m.group(1), e.group(1))] = (la, lb)
+        self.rules = [s for s in self.sentences if (_RULE.search(s['text']) and _PERMISSION.search(s['text'])) or _SCALE.search(s['text'])]
+        self.exceptions = [s for s in self.sentences if _EXCEPTION.search(s['text'])]
+        self.withdrawals = [s for s in self.sentences if _WITHDRAWAL.search(s['text'])]
+        # Reading conventions: sentences of the interpretation paragraphs (those holding a generic reading rule).
+        blocks = {self.paragraph_of(a) for a, _ in self.interpretation} - {None}
+        general = [s for s in self.sentences if self.paragraph_of(s['start']) in blocks and s not in self.rules]
+        self.conventions = {k: [(s['start'], s['end']) for s in general if rx.search(s['text'])] for k, rx in CONVENTIONS.items()}
+
+    def governed_rule(self, exception):
+        """The rule an exception limits: nearest preceding rule in the same paragraph (or the same sentence)."""
+        para = self.paragraph_of(exception['start'])
+        prior = [r for r in self.rules if r['start'] <= exception['start'] and para and para[0] <= r['start'] < para[1]
+                 and not _SCALE.search(r['text'])]
+        return prior[-1] if prior else None
+
+    def names(self, s, limit=16):
+        """Capitalised tokens that are rare in this source (subject names); months/number words excluded."""
+        out = set()
+        for tok in _CAP.findall(s):
+            tok = re.sub(r"'s$", '', tok)
+            w = tok.casefold()
+            if re.fullmatch(MONTHS, tok) or len(w) < 3 or w in _NOT_NAMES or (tok.isupper() and len(tok) > 1):
+                continue
+            if self.df.get(w, 0) <= limit:
+                out.add(tok)
+        return out
+
+    def paragraph_of(self, pos):
+        for a, b in self.paragraphs:
+            if a <= pos < b:
+                return a, b
+        return None
+
+    def line_of(self, pos):
+        for a, b in self.lines:
+            if a <= pos < b:
+                return a, b
+        return None
+
+    def container(self, span):
+        """(kind, key) of the message/minute/entry holding a span, else None."""
+        for key, (a, b) in self.entries.items():
+            if a <= span['start'] < b:
+                return ('entry', key)
+        para = self.paragraph_of(span['start'])
+        if para is None:
+            return None
+        for key, rng in self.messages.items():
+            if rng == para:
+                return ('message', key)
+        for key, rng in self.minutes.items():
+            if rng == para:
+                return ('minute', key)
+        return None
+
+    def references(self, sentence):
+        """Containers a withdrawal-type sentence refers to."""
+        out = []
+        for m in _REF_ENTRY.finditer(sentence):
+            out.append(('entry', (m.group(2), m.group(1))))
+        for m in _REF_DATE.finditer(sentence):
+            out.append(('message', m.group(1)))
+        for m in _REF_MINUTE.finditer(sentence):
+            out.append(('minute', m.group(1)))
+        return out
+
+    def container_range(self, ref):
+        kind, key = ref
+        return {'entry': self.entries, 'message': self.messages, 'minute': self.minutes}[kind].get(key)
+
+    def locators(self, span):
+        """Header ranges that place a span in its container (never the span's own text)."""
+        text, out = self.text, []
+        para = self.paragraph_of(span['start'])
+        if para is None:
+            return out
+        a, b = para
+        nl = text.find('\n', a, b)
+        if nl >= 0 and span['start'] > nl:
+            out.append((a, nl))  # first line of a multi-line block: message/section/schedule heading
+        else:
+            m = _MINUTE_HEAD.match(text, a)
+            if m and m.end() <= span['start']:
+                out.append((a, m.end()))  # numbered minute and its heading
+        line = self.line_of(span['start'])
+        if line and line[0] < span['start']:
+            prefix = text[line[0]:span['start']]
+            if len(prefix) <= 16 and _ENTRY_PREFIX.fullmatch(prefix):
+                out.append((line[0], span['start']))  # entry / clause number
+        return out
+
+    def sentence_ranges_in(self, rng):
+        a, b = rng
+        return [s for s in self.sentences if a <= s['start'] < b]
+
+
+def _strip(text, a, b):
+    while a < b and text[a].isspace():
+        a += 1
+    while b > a and text[b - 1].isspace():
+        b -= 1
+    return a, b
+
+
+def _merge(text, items):
+    """items: (start, end, role, reason) -> merged validated ranges; evidence role wins on overlap."""
+    cleaned = []
+    for a, b, role, reason in items:
+        a, b = _strip(text, a, b)
+        if a < b:
+            cleaned.append((a, b, role, reason))
+    cleaned.sort()
+    merged = []
+    for a, b, role, reason in cleaned:
+        if merged and a <= merged[-1]['end']:
+            m = merged[-1]
+            m['end'] = max(m['end'], b)
+            m['roles'].add(role)
+            m['reasons'].add(reason)
+        else:
+            merged.append({'start': a, 'end': b, 'roles': {role}, 'reasons': {reason}})
+    h = digest(text)
+    out = [{'id': f"text:{m['start']}:{m['end']}", 'kind': 'text', 'start': m['start'], 'end': m['end'],
+            'text': text[m['start']:m['end']], 'source_sha256': h,
+            'role': 'evidence' if 'evidence' in m['roles'] else 'context', 'reasons': sorted(m['reasons'])} for m in merged]
+    validate_spans(text, out)
+    return out
+
+
+def render(text, spans):
+    """Source-order rendering; separators are whitespace only and mirror the source layout."""
+    parts, last = [], None
+    for s in sorted(spans, key=lambda s: s['start']):
+        if last is not None:
+            gap = text[last:s['start']]
+            parts.append('\n\n' if '\n\n' in gap or re.search(r'\n\s*\n', gap) else ('\n' if '\n' in gap else ' '))
+        parts.append(text[s['start']:s['end']])
+        last = s['end']
+    return ''.join(parts)
+
+
+def build(text, question, evidence, *, subject=None, structure=None, options=None, cap=SIZE_CAP):
+    """One unit's evidence package.
+
+    evidence: selected (or gold, for oracle diagnostics) source spans for this unit.
+    subject: optional explicit subject string (entity name); otherwise rare capitalised question tokens.
+    """
+    opts = {'header': True, 'interpretation': True, 'locator': True, 'correction': True, 'withdrawn': True,
+            'rule': True, 'exception': True, 'definition': True, 'condition': True, 'convention': True, **(options or {})}
+    st = structure or Structure(text)
+    evidence = validate_spans(text, [{k: s[k] for k in ('start', 'end')} for s in evidence]) if evidence else []
+    items = [(s['start'], s['end'], 'evidence', 'selected') for s in evidence]
+    subj = st.names(subject if subject else question, limit=10 ** 9 if subject else 16)
+    if subject:
+        subj |= {subject}
+    qtopic = _topic(question, subj)
+    rare = st.names(question)
+
+    def mentions(t):
+        return (subject in t) if subject else bool(st.names(t) & rare)
+    if opts['header'] and st.paragraphs:
+        a, b = st.paragraphs[0]
+        items.append((a, min(b, a + 400), 'context', 'header'))
+    if opts['interpretation']:
+        items += [(a, b, 'context', 'interpretation') for a, b in st.interpretation]
+    if evidence:
+        included = [dict(s) for s in evidence]
+        if opts['rule']:
+            for r in st.rules:
+                if len(_topic(r['text'], subj) & qtopic) >= (3 if 'Attribute:' in question else 2):
+                    items.append((r['start'], r['end'], 'context', 'rule'))
+                    included.append(r)
+        # Iterate twice: attached statements can themselves need locators/corrections.
+        for _ in range(3):
+            current = [{'start': a, 'end': b} for a, b, role, reason in items
+                       if role == 'evidence' or reason in ('rule', 'exception', 'withdrawn', 'correction', 'definition', 'condition')]
+            spans = [s for s in st.sentences if any(max(s['start'], c['start']) < min(s['end'], c['end']) for c in current)]
+            for s in spans:
+                s_text = s['text']
+                if opts['exception'] and s in st.rules:
+                    for e in st.exceptions:
+                        g = st.governed_rule(e)
+                        if g is not None and g['start'] == s['start']:
+                            items.append((e['start'], e['end'], 'context', 'exception'))
+                if opts['exception'] and s in st.exceptions:
+                    g = st.governed_rule(s)
+                    if g is not None:
+                        items.append((g['start'], g['end'], 'context', 'exception'))
+                if opts['definition'] and s in st.rules:
+                    for term in set(re.findall(r'(?<=[a-z,;] )([A-Z][a-z]+ [A-Z][a-z]+?)s?\b', s_text)):
+                        for d in st.sentences:
+                            if term in d['text'] and _DEFINES.search(d['text']) and d['start'] < s['start'] and mentions(d['text']):
+                                items.append((d['start'], d['end'], 'context', 'definition'))
+                if opts['condition'] and s in st.rules:
+                    # Facts about this unit's subject that bear on the rule's conditions or its exception.
+                    governing = [s] + [e for e in st.exceptions if (st.governed_rule(e) or {}).get('start') == s['start']]
+                    words = set().union(*(_topic(g['text'], subj) for g in governing)) - qtopic
+                    for t in st.sentences:
+                        shared = _topic(t['text'], subj) & words
+                        if t['start'] != s['start'] and mentions(t['text']) and (len(shared) >= 2 or any(st.df.get(w, 0) <= 3 for w in shared)):
+                            items.append((t['start'], t['end'], 'context', 'condition'))
+                if opts['locator']:
+                    items += [(a, b, 'context', 'locator') for a, b in st.locators(s)]
+                is_withdrawal = bool(_WITHDRAWAL.search(s_text))
+                if opts['withdrawn'] and is_withdrawal:
+                    wnames = st.names(s_text)
+                    for ref in st.references(s_text):
+                        rng = st.container_range(ref)
+                        if rng is None:
+                            continue
+                        if ref[0] == 'entry':
+                            items.append((rng[0], rng[1], 'context', 'withdrawn'))
+                            continue
+                        for t in st.sentence_ranges_in(rng):
+                            if t['start'] == s['start']:
+                                continue
+                            if st.names(t['text']) & wnames and _topic(t['text'], wnames) & _topic(s_text, wnames):
+                                items.append((t['start'], t['end'], 'context', 'withdrawn'))
+                if opts['correction'] and not is_withdrawal:
+                    where = st.container(s)
+                    if where is None:
+                        continue
+                    snames = st.names(s_text)
+                    for w in st.withdrawals:
+                        if w['start'] == s['start'] or where not in st.references(w['text']):
+                            continue
+                        if where[0] == 'entry' or (st.names(w['text']) & snames and _topic(w['text'], snames) & _topic(s_text, snames)):
+                            items.append((w['start'], w['end'], 'context', 'correction'))
+    if opts['convention']:
+        reasons = {r for _, _, _, r in items}
+        ev_text = ' '.join(text[a:b] for a, b, role, _ in items if role == 'evidence')
+        wanted = {'silence'}
+        if evidence:
+            wanted |= {'conflict', 'vocabulary'}
+        if reasons & {'correction', 'withdrawn'} or _WITHDRAWAL.search(ev_text):
+            wanted.add('removal')
+        if 'rule' in reasons or any(r['start'] < b and a < r['end'] for r in st.rules if not _SCALE.search(r['text'])
+                                      for a, b, role, _ in items if role == 'evidence'):
+            wanted.add('condition')
+        if 'exception' in reasons:
+            wanted.add('exception')
+        for kind in sorted(wanted):
+            items += [(a, b, 'context', 'convention/'+kind) for a, b in st.conventions[kind]]
+    spans = _merge(text, items);trimmed = []
+    def size(sp):return sum(x['end'] - x['start'] for x in sp) / len(text) if text else 0.
+    for reason in (TRIM_ORDER if cap is not None else ()):
+        if size(spans) <= cap:
+            break
+        keep = [it for it in items if it[3] != reason]
+        if len(keep) != len(items):
+            items = keep;trimmed.append(reason);spans = _merge(text, items)
+    rendered = render(text, spans)
+    covered = sum(s['end'] - s['start'] for s in spans)
+    return {'schema': SCHEMA, 'question': question, 'source_sha256': digest(text), 'text': rendered, 'spans': spans,
+            'size_cap': cap, 'within_size_cap': cap is None or covered <= cap * len(text), 'trimmed_for_cap': trimmed,
+            'evidence_ranges': [{'start': s['start'], 'end': s['end']} for s in evidence],
+            'no_support_found': not evidence, 'source_characters': len(text), 'covered_characters': covered,
+            'rendered_characters': len(rendered), 'source_fraction': covered / len(text) if text else 0.,
+            'context_reasons': sorted({r for s in spans for r in s['reasons'] if r != 'selected'}),
+            'faithfulness_established': False}
+
+
+def union(text, packages):
+    """One document-level package: union of unit packages (used for whole-question rendering)."""
+    items = [(s['start'], s['end'], s['role'], r) for p in packages for s in p['spans'] for r in s['reasons']]
+    if not items:
+        return {'schema': SCHEMA, 'text': '', 'spans': [], 'source_fraction': 0., 'covered_characters': 0,
+                'source_characters': len(text), 'rendered_characters': 0, 'source_sha256': digest(text)}
+    spans = _merge(text, items)
+    rendered = render(text, spans)
+    covered = sum(s['end'] - s['start'] for s in spans)
+    return {'schema': SCHEMA, 'text': rendered, 'spans': spans, 'source_fraction': covered / len(text),
+            'covered_characters': covered, 'source_characters': len(text), 'rendered_characters': len(rendered),
+            'source_sha256': digest(text)}
+
+
+def with_pages(package, text, page_map):
+    """Attach renderer page IDs to every package span (scope6.sources.evidence_pages)."""
+    from scope6.sources import evidence_pages
+    out = dict(package)
+    out['spans'] = [{**s, 'pages': evidence_pages(text, [s], page_map)} for s in package['spans']]
+    out['pages'] = sorted({p for s in out['spans'] for p in s['pages']})
+    return out

mlx/src/solomon_mlx/_vendor/prompts.py

@@ -0,0 +1,43 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.
+SYSTEM = 'You answer questions about the supplied document. Use only the document. Task instructions follow the document; follow them exactly.'
+
+BOOLEAN_TASK = 'Task: classify the evidence for the question using only the document and its explicit rules. A = Yes only. B = No only. C = neither Yes nor No is established. D = both Yes and No are established. A missing fact is not a negative fact. Evidence about another person or subject does not contradict the queried one. Apply explicit time and replacement rules before deciding. Respond with exactly one letter: A, B, C, or D. Do not explain.'
+
+CHOICE_TASK = 'Task: choose the single option that the document best supports. Respond with exactly one letter. Do not explain.'
+
+def boolean_block(question):
+    return BOOLEAN_TASK + '\nQuestion: ' + question + '\nAnswer (one letter):'
+LETTERS = 'ABCDEFGHIJ'
+
+PAGE = '<|vision_start|><|image_pad|><|vision_end|>'
+
+RESERVED = ['The document does not state this', 'The document gives conflicting answers']
+
+SINGLE_R = 'Task: choose the single option that the document establishes as the answer. If the document does not establish any of the other listed answers, choose the option that says it does not state this. If the document establishes two different listed answers and does not say which prevails, choose the option that says it gives conflicting answers. A replaced or withdrawn statement establishes nothing. Respond with exactly one letter. Do not explain.'
+
+ORDERED_R = 'Task: the options form an ordered scale, lowest first, followed by two special options. Choose the single level that the document establishes. If the document does not establish any level, choose the option that says it does not state this. If it establishes two different levels and does not say which prevails, choose the option that says it gives conflicting answers. A replaced or withdrawn statement establishes nothing. Respond with exactly one letter. Do not explain.'
+
+SINGLE_S = CHOICE_TASK
+
+ORDERED_S = 'Task: the options form an ordered scale, lowest first. Choose the single level that the document best supports. Respond with exactly one letter. Do not explain.'
+
+SUFFICIENCY = 'Task: classify what the document establishes about the answer to the question, using only the document. A = it establishes exactly one of the listed answers. B = it does not establish any of the listed answers. C = it establishes two or more different listed answers and does not say which prevails. A missing fact is not a negative fact. A replaced or withdrawn statement establishes nothing. Respond with exactly one letter: A, B, or C. Do not explain.'
+
+LABEL = 'Task: decide whether the label applies, using only the document. A = the document establishes that it applies, and nothing in it establishes that it does not. B = the document establishes that it does not apply, and nothing in it establishes that it does. C = the document establishes neither. D = the document establishes both. A missing fact is not a negative fact. Evidence about another person or subject does not count. A replaced or withdrawn statement establishes nothing. Respond with exactly one letter: A, B, C, or D. Do not explain.'
+
+OPTION = 'Task: decide whether the proposed answer is correct, using only the document. A = the document establishes this answer, and nothing in it establishes a different one. B = the document establishes a different answer, or establishes that this one is wrong, and nothing in it establishes this one. C = the document establishes neither. D = the document establishes both this answer and a different one. A missing fact is not a negative fact. A replaced or withdrawn statement establishes nothing. Respond with exactly one letter: A, B, C, or D. Do not explain.'
+
+def _lettered(options):
+    return '\n'.join((f'{LETTERS[i]}. {text}' for i, text in enumerate(options)))
+
+def listwise_block(question, options, ordered=False, reserved=True):
+    """Caller options in caller order; with `reserved` the service appends the two reserved outcomes."""
+    if not 2 <= len(options) <= 8 or len(set(options)) != len(options):
+        raise ValueError('needs 2 to 8 distinct options')
+    shown = list(options) + (RESERVED if reserved else [])
+    task = (ORDERED_R if ordered else SINGLE_R) if reserved else ORDERED_S if ordered else SINGLE_S
+    return (task + '\nQuestion: ' + question + '\nOptions:\n' + _lettered(shown) + '\nAnswer (one letter):', len(shown))
+
+def label_block(question, label):
+    return (LABEL + '\nQuestion: ' + question + '\nLabel: ' + label + '\nAnswer (one letter):', 4)

mlx/src/solomon_mlx/_vendor/retrieval.py

@@ -0,0 +1,152 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.
+"""Inference-only source candidates and explicitly labelled retrieval baselines."""
+import re
+from .evidence import digest,rank_candidates,validate_spans
+
+def candidates(text):
+    """Source sentences retaining exact character ranges; no authoring labels."""
+    ends=[m.end() for m in re.finditer(r'(?<=[.!?])(?:[ \t]+|\n+)|\n\s*\n',text)]+[len(text)]
+    result=[];start=0
+    for end in ends:
+        if end>start and text[start:end].strip():
+            result.append({'id':f'text:{start}:{end}','kind':'text','start':start,'end':end,
+                           'text':text[start:end],'source_sha256':digest(text)})
+        start=end
+    return result
+
+def governing_context(text,spans=None):
+    """Generic rule/retraction interpretation context, independent of question gold."""
+    spans=candidates(text) if spans is None else spans
+    pattern=re.compile(r'general rule|both limbs|same (?:person|courier|member|officer)|neither limb|missing requirement|silence|withdrawn passage|dates and seniority|a withdrawn|outside these|bands are|order of the levels|no.*precedence|each passage|a grant in force|an exception to a rule',re.I)
+    return [s for s in spans if pattern.search(s['text'])]
+
+def merge(text,spans):
+    intervals=[]
+    for span in sorted(spans,key=lambda s:(s['start'],s['end'])):
+        a,b=span['start'],span['end']
+        if intervals and a<=intervals[-1][1]:intervals[-1]=(intervals[-1][0],max(b,intervals[-1][1]))
+        else:intervals.append((a,b))
+    result=[{'id':f'text:{a}:{b}','kind':'text','start':a,'end':b,'text':text[a:b],'source_sha256':digest(text)} for a,b in intervals]
+    return validate_spans(text,result)
+
+def render_subset(text,spans,*,include_context=True):
+    selected=merge(text,list(spans)+(governing_context(text) if include_context else []))
+    return '\n\n'.join(s['text'] for s in selected),selected
+
+_WORD=re.compile(r'\w+')
+_SCALE=re.compile(r'\bbands?\b|\bscale\b|from lowest to highest|order of the levels',re.I)
+POOL_V2={'name':'idf-rare-rule-v2','idf_limit':24,'rare_df':16,'rules':True}
+
+def _words(s):return set(_WORD.findall(s.casefold()))
+
+def rule_candidates(text,spans=None):
+    """Question-independent rule, exception, withdrawal-convention and scale passages."""
+    spans=candidates(text) if spans is None else spans
+    rules={s['id'] for s in governing_context(text,spans)}
+    return [s for s in spans if s['id'] in rules or _SCALE.search(s['text'])]
+
+def candidate_pool(question,spans,text=None,*,idf_limit=24,rare_df=16,rules=True,**_):
+    """Bounded source-only pool: document-IDF top-k, every passage sharing a rare
+    question term (typically the subject's name), plus question-independent rules.
+
+    Candidate order is source order. candidate_score stays the plain lexical-overlap
+    fraction used by the frozen relevance-head feature, so heads remain comparable.
+    Gold is never an input.
+    """
+    import math
+    if idf_limit<1 or rare_df<0:raise ValueError('invalid candidate pool policy')
+    ranked=rank_candidates(question,spans,len(spans)) if spans else []
+    words=[_words(c['text']) for c in ranked];q=_words(question);n=len(ranked)
+    df={}
+    for ws in words:
+        for w in ws:df[w]=df.get(w,0)+1
+    idf=[sum(math.log((n+1)/(df[w]+.5)) for w in ws&q) for ws in words]
+    order=sorted(range(n),key=lambda i:(-idf[i],ranked[i]['start']))
+    reason={}
+    for i in order[:idf_limit]:reason.setdefault(ranked[i]['id'],'idf')
+    rare={w for w in q if df.get(w,0)<=rare_df}
+    for c,ws in zip(ranked,words):
+        if ws&rare:reason.setdefault(c['id'],'rare_term')
+    if rules:
+        for c in rule_candidates(text or '',ranked):reason.setdefault(c['id'],'rule')
+    return sorted(({**c,'pool_reason':reason[c['id']]} for c in ranked if c['id'] in reason),key=lambda c:c['start'])
+
+_WITHDRAW=re.compile(r'withdr[ae]w|withdrawn|take back|disregard|rescind|retract|should not be relied|there is substituted|is deleted|expressly delete',re.I)
+_REFERENCE=re.compile(r'(?:message of|wrote on|message dated) (\d{1,2} [A-Z][a-z]+)|minute (\d+)|[Ee]ntry (\d+) of [Ss]chedule (\d+)|clause ([\d.]+)|passage in my message')
+_EXCEPTION=re.compile(r'does not apply to|subject to the exception|is an exception|except (?:where|that|for)\b',re.I)
+_STOP={'this','that','these','those','with','under','which','what','does','file','correspondence','record','records','recorded',
+       'minutes','agreement','bundle','messages','message','stand','stands','taking','reading','whole','strength','position',
+       'open','given','have','been','applies','apply','entitled','allowed','liberty','free','from','there','their','they',
+       'decisions','here','schedules','schedule','papers','office','shown','show','shows','case','matters','terms','place','placed'}
+DEPENDENCIES_V1={'name':'withdrawal-exception-v1','withdrawals':True,'exceptions':True,'prune_withdrawn':False,'rare_df':16}
+
+def _topic(words,exclude):
+    return {w for w in words if len(w)>=4 and w not in _STOP and w not in exclude and not w.isdigit()}
+
+def _withdrawn_block(text,passage):
+    """Source range that a withdrawal refers to (dated message or numbered minute); None if not resolvable."""
+    m=_REFERENCE.search(passage)
+    if not m:return None
+    if m.group(1):head=re.search(r'Message \d+\. '+re.escape(m.group(1))+r'\.',text)
+    elif m.group(2):head=re.search(r'(?:^|\n)'+m.group(2)+r'\. ',text)
+    else:return None
+    if not head:return None
+    end=text.find('\n\n',head.end());return head.start(),(len(text) if end<0 else end)
+
+def dependency_expand(question,spans,selected_ids,text,*,withdrawals=True,exceptions=True,prune_withdrawn=False,rare_df=16,**_):
+    """Complete a unit's selected evidence with its withdrawal/exception dependencies.
+
+    Source text and the already-selected passages only; never gold. Units with no
+    selection are unchanged, so no-positive-support decisions are preserved.
+    - withdrawal: a passage with a withdrawal verb AND an explicit reference (message/minute/
+      entry/clause) that names the question's subject (a rare capitalised name, also present in a
+      selected passage) and its most specific in-source topic word;
+    - exception: an exception clause immediately following a selected passage;
+    - prune_withdrawn (optional): drop selected passages inside the dated message / numbered
+      minute a kept withdrawal refers to, when they share its subject and a topic word.
+    Returns {'keep','added','pruned'} as candidate id lists in source order.
+    """
+    selected=[s for s in spans if s['id'] in set(selected_ids)]
+    if not selected:return {'keep':[],'added':[],'pruned':[]}
+    words=[_words(s['text']) for s in spans];df={}
+    for ws in words:
+        for w in ws:df[w]=df.get(w,0)+1
+    # Subject: capitalised non-initial question tokens (names) that are rare in the source.
+    names=re.findall(r'(?<!^)(?<![.?!] )\b[A-Z][\w&\'-]*',question.strip())
+    subject={w for n in names for w in _words(n) if len(w)>=3 and df.get(w,0)<=rare_df}
+    q=_words(question);present=[w for w in _topic(q,subject) if df.get(w,0)]
+    # The withdrawal must name the question's most specific in-source topic word (e.g. the attribute).
+    topic={min(present,key=lambda w:(df[w],w))} if present else set()
+    chosen={s['id'] for s in selected};sel_words=set().union(*(_words(s['text']) for s in selected));added=[]
+    for i,(s,ws) in enumerate(zip(spans,words)):
+        if s['id'] in chosen:continue
+        if (withdrawals and _WITHDRAW.search(s['text']) and _REFERENCE.search(s['text'])
+                and ws&subject&sel_words and ws&topic):added.append(s['id']);continue
+        if exceptions and i>0 and spans[i-1]['id'] in chosen and _EXCEPTION.search(s['text']):added.append(s['id'])
+    keep=chosen|set(added);pruned=[]
+    if prune_withdrawn:
+        for s,ws in zip(spans,words):
+            if s['id'] not in keep or not _WITHDRAW.search(s['text']):continue
+            block=_withdrawn_block(text,s['text'])
+            if block is None:continue
+            key=ws&subject;about=_topic(ws,subject)
+            for t,tw in zip(spans,words):
+                if (t['id'] in keep and t['id']!=s['id'] and block[0]<=t['start'] and t['end']<=block[1]+2
+                        and tw&key and tw&about and not _WITHDRAW.search(t['text'])):pruned.append(t['id'])
+    order=[s['id'] for s in spans];pruned=set(pruned)
+    return {'keep':[i for i in order if i in keep and i not in pruned],'added':[i for i in order if i in set(added)],
+            'pruned':[i for i in order if i in pruned]}
+
+def lexical_select(text,questions,limit=4):
+    source=candidates(text);chosen={}
+    for q in questions:
+        for candidate in rank_candidates(q,source,limit):
+            if candidate['candidate_score']>0:chosen[candidate['id']]=candidate
+    return {'evidence':sorted(chosen.values(),key=lambda c:c['start']),
+            'method':'lexical_overlap','verification':'retrieval_only','faithfulness_established':False}
+
+def remove(text,spans):
+    spans=merge(text,spans);cursor=0;parts=[]
+    for s in spans:parts.append(text[cursor:s['start']]);cursor=s['end']
+    parts.append(text[cursor:]);return ''.join(parts)

mlx/src/solomon_mlx/_vendor/semantics.py

@@ -0,0 +1,71 @@
+# Copyright 2026 Doccy Pty Ltd. Apache-2.0.
+# Adapted from pinned Solomon v1.1; see NOTICE and MODIFICATIONS.md.
+"""Scope 9 answer semantics (docs/plans/2026-09-20-scope9-noul-final-refinement.md §1).
+
+Yes/no, entity and multi-label candidates are Nouls: one probability P(yes). Gold yes only when the
+document clearly establishes it; not stated and conflicting are no. Choice (single, ordered) is a
+distribution over the listed options only; reserved-gold items have no Scope 9 target.
+
+Works for both readouts: four_collapsed (four-state letter logits A/B/C/D, collapsed) and two_letter (A/B).
+"""
+import numpy as np
+
+YES, NO, NOT_STATED, CONFLICTING = 0, 1, 2, 3
+
+
+def softmax(x, t=1.0):
+    z = np.asarray(x, np.float64) / t
+    z = z - z.max()
+    e = np.exp(z)
+    return e / e.sum()
+
+
+def noul_gold(gold4):
+    """Four-state (or two-state) gold -> 1 for yes, 0 for no."""
+    return int(int(gold4) == YES)
+
+
+def noul_logit(letter_logits):
+    """Binary log-odds z = log P(yes)/P(no) of a Noul branch: letter A against everything else."""
+    logits = np.asarray(letter_logits, np.float64)
+    if len(logits) not in (2, 4):
+        raise ValueError(f'Noul branch must have 2 or 4 letters, got {len(logits)}')
+    rest = logits[1:] - logits[1:].max()
+    return float(logits[YES] - (logits[1:].max() + np.log(np.exp(rest).sum())))
+
+
+def p_yes(letter_logits, t=1.0):
+    """P(yes) from a Noul branch: letter A of a 2-letter (two_letter) or 4-state (four_collapsed) readout.
+
+    Temperature applies to the COLLAPSED binary logit, not to the letters: a Noul is a binary unit whose
+    'no' mass may be spread over several reserved letters, so p_yes(t) = sigmoid(z/t) with z = noul_logit.
+    At t = 1 this is exactly softmax over the letters at A (the two forms only differ once t != 1, where the
+    letterwise form would decay toward 1/len(letters) instead of toward 1/2). scope9.qualification.p_yes and
+    abstention_refit/readout.py fit and evaluate the collapsed form, so the serving path must match it.
+    """
+    logits = np.asarray(letter_logits, np.float64)
+    if len(logits) not in (2, 4):
+        raise ValueError(f'Noul branch must have 2 or 4 letters, got {len(logits)}')
+    if t == 1.0:
+        return float(softmax(logits)[YES])
+    z = noul_logit(logits) / float(t)
+    return float(1.0 / (1.0 + np.exp(-z))) if z > -700 else 0.0
+
+
+def noul_confidence(p):
+    return max(p, 1.0 - p)
+
+
+def listed_gold(gold, n_options):
+    """Listed option index, or None when the old gold was a reserved slot (not stated / none-of-listed / conflicting)."""
+    return int(gold) if isinstance(gold, (int, np.integer)) and 0 <= int(gold) < n_options else None
+
+
+def listed_probs(letter_logits, n_options, t=1.0):
+    """Choice distribution over the listed options only (reserved slots, if present, are discarded)."""
+    return softmax(np.asarray(letter_logits, np.float64)[:n_options], t)
+
+
+def complement_deviation(p, p_negated):
+    """G3a under Scope 9: a statement and its negation should sum to 1."""
+    return abs(p - (1.0 - p_negated))

mlx/src/solomon_mlx/api.py

@@ -0,0 +1,321 @@
+"""Public document-state API and four-state answer semantics."""
+
+import copy
+import json
+import math
+from pathlib import Path
+
+from ._vendor.contract import _state_parts, decision, parse_questions, present
+from ._vendor.prompts import boolean_block, label_block, listwise_block
+from ._vendor.semantics import listed_probs, p_yes
+from .artifacts import digest, sha256
+
+TASKS = ("boolean", "single", "ordered", "multilabel", "entity")
+
+
+def branches(spec):
+    task, req = spec["task"], spec["request"]
+    if task == "boolean":
+        return [(boolean_block(req["question"]), 4, "boolean/state4")]
+    if task in ("single", "ordered"):
+        block, width = listwise_block(
+            req["question"], req["options"], ordered=task == "ordered", reserved=task == "single"
+        )
+        return [(block, width, task + ("/choiceR" if task == "single" else "/choiceS"))]
+    if task == "entity":
+        return [
+            (boolean_block(req["template"].replace("{entity}", c)), 4, "entity/state4")
+            for c in req["entities"]
+        ]
+    return [(*label_block(req["question"], c), "multilabel/state4") for c in req["labels"]]
+
+
+def distributions(spec, rows, temperature):
+    if spec["task"] in ("boolean", "entity", "multilabel"):
+        values = [p_yes(r["letter_logits"], temperature) for r in rows]
+        return [[p, 1 - p] for p in values]
+    return [listed_probs(rows[0]["letter_logits"], len(spec["texts"]), temperature).tolist()]
+
+
+def ordering_score(values):
+    """Product of per-unit top probabilities; not a calibrated joint probability."""
+    if not values:
+        raise ValueError("At least one answer unit is required")
+    for p in values:
+        if len(p) < 2 or not all(math.isfinite(v) and v >= 0 for v in p) or abs(sum(p) - 1) > 1e-6:
+            raise ValueError("Invalid answer distribution")
+    return math.prod(max(p) for p in values)
+
+
+class DocumentState:
+    def __init__(self, owner, data):
+        self._owner, self._data, self.closed = owner, data, False
+        self.image_hashes = {p["image"]: sha256(p["image"]) for p in data["parts"] if "image" in p}
+
+    @property
+    def prefix_tokens(self):
+        self._check()
+        return len(self._data["prefix_ids"])
+
+    def _check(self):
+        if self.closed:
+            raise ValueError("Document state is closed")
+        if any(sha256(path) != value for path, value in self.image_hashes.items()):
+            raise ValueError("Document image changed after prefill")
+
+    def save(self, path):
+        """Save a source-bound replay recipe, never pickle executable cache objects."""
+        self._check()
+        body = {
+            "format": "solomon-mlx-replay-v1",
+            "runtime": self._owner.identity["fingerprint"],
+            "parts": self._data["parts"],
+            "image_hashes": self.image_hashes,
+            "prefix_ids_sha256": digest(self._data["prefix_ids"]),
+        }
+        Path(path).write_text(json.dumps({**body, "sha256": digest(body)}, indent=2))
+
+    def close(self):
+        with self._owner.engine.lock:
+            self._data.clear()
+            self.closed = True
+
+    def __enter__(self):
+        self._check()
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class Solomon:
+    @classmethod
+    def load(
+        cls,
+        model_dir,
+        profile="quality",
+        *,
+        chunk_size=2048,
+        max_tokens=40960,
+        page_selector=None,
+        calibration=None,
+    ):
+        if profile != "quality":
+            raise ValueError("Only full BF16 quality is implemented; quantization is secondary")
+        from .engine import Engine
+
+        return cls(
+            Engine(model_dir, chunk_size=chunk_size, max_tokens=max_tokens),
+            page_selector=page_selector,
+            calibration=calibration,
+        )
+
+    def __init__(self, engine, *, page_selector=None, calibration=None):
+        self.engine, self.identity, self.page_selector = engine, engine.identity, page_selector
+        self.temperatures = dict.fromkeys(TASKS, 1.0)
+        self.calibration_status = "uncalibrated"
+        if calibration is not None:
+            artifact = json.loads(Path(calibration).read_text())
+            payload = {k: v for k, v in artifact.items() if k != "sha256"}
+            if (
+                artifact.get("sha256") != digest(payload)
+                or artifact["runtime"] != self.identity["fingerprint"]
+            ):
+                raise ValueError("Calibration checksum or MLX runtime identity mismatch")
+            temps = artifact["temperatures"]
+            if set(temps) != set(TASKS) or any(
+                isinstance(v, bool)
+                or not isinstance(v, (int, float))
+                or not math.isfinite(v)
+                or not 0 < v <= 20
+                for v in temps.values()
+            ):
+                raise ValueError("Invalid temperatures")
+            self.temperatures, self.calibration_status = temps, "profile_fitted"
+
+    def prefill(self, document):
+        parts = copy.deepcopy(_state_parts(document))
+        if not parts:
+            parts = [{"text": ""}]
+        for p in parts:
+            if not isinstance(p, dict) or set(p) not in ({"text"}, {"image"}):
+                raise ValueError("Each document part must contain only text or image")
+            if "text" in p and not isinstance(p["text"], str):
+                raise ValueError("Text parts must be strings")
+            if "image" in p:
+                p["image"] = str(Path(p["image"]).resolve(strict=True))
+        hashes = {p["image"]: sha256(p["image"]) for p in parts if "image" in p}
+        state = DocumentState(self, self.engine.prefill(parts))
+        if state.image_hashes != hashes:
+            state.close()
+            raise ValueError("Image changed while document was being prefilled")
+        return state
+
+    def replay(self, path):
+        body = json.loads(Path(path).read_text())
+        expected = body.pop("sha256")
+        if (
+            digest(body) != expected
+            or body["format"] != "solomon-mlx-replay-v1"
+            or body["runtime"] != self.identity["fingerprint"]
+        ):
+            raise ValueError("Replay checksum or runtime mismatch")
+        if any(sha256(p) != h for p, h in body["image_hashes"].items()):
+            raise ValueError("Replay image changed")
+        state = self.prefill(body["parts"])
+        if digest(state._data["prefix_ids"]) != body["prefix_ids_sha256"]:
+            state.close()
+            raise ValueError("Replay tokenization differs")
+        return state
+
+    def _answer(self, state, spec, execution="cached"):
+        rows = [self.engine.ask(state._data, b, n, h, execution=execution) for b, n, h in branches(spec)]
+        dists = distributions(spec, rows, self.temperatures[spec["task"]])
+        return {
+            **present(spec, dists),
+            "ordering_score": ordering_score(dists),
+            "temperature": self.temperatures[spec["task"]],
+        }, rows
+
+    def decide(
+        self,
+        *,
+        state,
+        questions,
+        evidence="support",
+        evidence_max_calls=64,
+        execution="cached",
+        diagnostics=False,
+    ):
+        if not isinstance(state, DocumentState) or state._owner is not self:
+            raise ValueError("State belongs to a different model instance")
+        if evidence not in ("none", "support", "sufficiency", "removal"):
+            raise ValueError("Invalid evidence level")
+        if type(evidence_max_calls) is not int or not 0 <= evidence_max_calls <= 512:
+            raise ValueError("Invalid evidence call budget")
+        specs = parse_questions(questions)
+        with self.engine.lock:
+            state._check()
+            answers, usage = {}, {"branches": 0, "input_tokens": 0, "evidence_calls": 0}
+            for spec in specs:
+                answer, rows = self._answer(state, spec, execution)
+                body = self._evidence(state, spec, answer, evidence, evidence_max_calls)
+                answer.update(
+                    evidence=body["references"], evidence_status=body["status"], evidence_detail=body
+                )
+                if diagnostics:
+                    answer["branches"] = rows
+                answers[spec["id"]] = answer
+                usage["branches"] += len(rows)
+                usage["input_tokens"] += sum(
+                    r["branch_tokens"] if execution == "cached" else r["prompt_tokens"] for r in rows
+                )
+                usage["evidence_calls"] += body.get("calls", 0)
+            return {
+                "answers": answers,
+                "usage": usage,
+                "runtime": self.identity,
+                "calibration_status": self.calibration_status,
+                "answer_policy": "always_answers",
+            }
+
+    def _fresh(self, document, spec):
+        with self.prefill(document) as state:
+            answer, _ = self._answer(state, spec)
+            return decision(spec, answer)
+
+    def _evidence(self, state, spec, answer, level, budget):
+        from ._vendor import evidence_v3 as v3
+        from ._vendor.evidence import image_pages, validate_pages, validate_spans
+        from ._vendor.retrieval import lexical_select, remove
+
+        body = {
+            "references": [],
+            "status": "not_requested",
+            "calls": 0,
+            "verification": "none",
+            "faithfulness_established": False,
+        }
+        if level == "none":
+            return body
+        parts, req = state._data["parts"], spec["request"]
+        task = spec["task"]
+        if task == "entity":
+            questions = [req["template"].replace("{entity}", c) for c in req["entities"]]
+        elif task == "multilabel":
+            questions = [req["question"] + " Label: " + c for c in req["labels"]]
+        else:
+            questions = [req["question"] + (" " + " ".join(req["options"]) if "options" in req else "")]
+        images = [p["image"] for p in parts if "image" in p]
+        needed = (1 if images else len(questions)) if level in ("sufficiency", "removal") else 0
+        needed += int(level == "removal")
+        if needed > budget:
+            return {**body, "status": "budget_exhausted", "required_calls": needed}
+        baseline = decision(spec, answer)
+        if images:
+            if self.page_selector is None:
+                return {**body, "status": "unsupported_page_selector", "pages_available": len(images)}
+            pages = image_pages(images)
+            selector = self.page_selector
+            plan = None
+            if hasattr(selector, "plan"):
+                plan = selector.plan(
+                    pages, questions, **({"task": task} if getattr(selector, "task_aware", False) else {})
+                )
+                if type(plan.get("calls")) is not int or plan["calls"] < 0:
+                    raise ValueError("Invalid page selector call estimate")
+                if needed + plan["calls"] > budget:
+                    return {**body, "status": "budget_exhausted", "required_calls": needed + plan["calls"]}
+            selection = (
+                selector.execute(plan) if plan is not None else selector(copy.deepcopy(pages), questions)
+            )
+            calls = selection.get("cost", {}).get("calls", 0)
+            if calls != (plan["calls"] if plan is not None else 0):
+                raise ValueError("Page selector exceeded its declared call budget")
+            refs = validate_pages(pages, selection["evidence"])
+            body["calls"] = calls
+            selected = {r["page"] for r in refs}
+            page, remainder = 0, []
+            for part in parts:
+                if "image" in part:
+                    page += 1
+                    if page in selected:
+                        continue
+                remainder.append(part)
+            subsets = [([{"image": r["path"]} for r in refs], spec)]
+        else:
+            text = "".join(p["text"] for p in parts)
+            selection = lexical_select(text, questions)
+            refs = validate_spans(text, selection["evidence"])
+            structure = v3.Structure(text)
+            packages, subsets = [], []
+            for i, q in enumerate(questions):
+                subject = req["entities"][i] if task == "entity" else None
+                package = v3.build(text, q, refs, subject=subject, structure=structure)
+                unit = copy.deepcopy(spec)
+                if "candidates" in spec:
+                    candidate = spec["candidates"][i]
+                    unit["candidates"] = [candidate]
+                    unit["request"]["entities" if task == "entity" else "labels"] = [candidate]
+                subsets.append((package["text"], unit))
+                packages.append({k: v for k, v in package.items() if k != "text"})
+            body["packages"] = packages
+            remainder = remove(text, refs)
+        body.update(
+            references=refs, status="found" if refs else "no_support_found", verification="retrieval_only"
+        )
+        if level in ("sufficiency", "removal"):
+            predictions = [self._fresh(doc, unit) for doc, unit in subsets]
+            assembled = (
+                {k: v for d in predictions for k, v in d.items()}
+                if "candidates" in spec and not images
+                else predictions[0]
+            )
+            body["evidence_only"] = {"prediction": assembled, "agrees_with_full": assembled == baseline}
+            body["calls"] += len(subsets)
+            body["verification"] = "fresh_source_reencoding"
+        if level == "removal":
+            removed = self._fresh(remainder, spec)
+            body["evidence_removed"] = {"prediction": removed, "agrees_with_full": removed == baseline}
+            body["calls"] += 1
+        return body

mlx/src/solomon_mlx/artifacts.py

@@ -0,0 +1,77 @@
+"""Artifact verification and distinct MLX runtime identities."""
+
+import hashlib
+import json
+from importlib.metadata import version
+from pathlib import Path
+
+SOLOMON_REVISION = "2ec506902269e4636285c8811f6c0f52c9300c0c"
+BASE_REVISION = "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0"
+ADAPTER_SHA = "2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca"
+HEADS_SHA = "126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f"
+
+
+def sha256(path):
+    h = hashlib.sha256()
+    with Path(path).open("rb") as f:
+        for block in iter(lambda: f.read(8 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def digest(value):
+    return hashlib.sha256(
+        json.dumps(value, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()
+    ).hexdigest()
+
+
+def verify_release(root):
+    root = Path(root)
+    manifest = json.loads((root / "MANIFEST.json").read_text())
+    checked = {}
+    for row in manifest["files"]:
+        rel = row["destination"]
+        path = (root / rel).resolve()
+        if not path.is_relative_to(root.resolve()):
+            raise ValueError("Manifest path escapes source directory")
+        expected = row.get("staged_sha256")
+        size = row.get("staged_bytes")
+        actual = sha256(path)
+        if expected and actual != expected:
+            raise ValueError(f"Source checksum mismatch: {rel}")
+        if size is not None and path.stat().st_size != size:
+            raise ValueError(f"Source size mismatch: {rel}")
+        checked[rel] = actual
+    return checked
+
+
+def code_identity():
+    root = Path(__file__).parent
+    return digest({str(p.relative_to(root)): sha256(p) for p in sorted(root.rglob("*.py"))})
+
+
+def runtime_identity(binding, *, chunk_size=2048, max_tokens=40960):
+    import platform
+
+    import mlx.core as mx
+
+    value = {
+        "backend": "mlx-metal",
+        "contract": "solomon-mlx-v1",
+        "source_contract": "solomon-v1",
+        "profile": binding["profile"],
+        "chunk_size": chunk_size,
+        "max_tokens": max_tokens,
+        "metal_device": mx.device_info(),
+        "macos_version": platform.mac_ver()[0],
+        "model_binding": digest(binding),
+        "code_sha256": code_identity(),
+        "versions": {p: version(p) for p in ("mlx", "mlx-vlm", "transformers", "numpy", "pillow")},
+        "placement": "question",
+        "lora_scale": 2.0,
+        "answer_projection": "trained-semantic-head-float32",
+        "recurrence": "mlx-float32",
+        "solomon_revision": SOLOMON_REVISION,
+        "base_revision": BASE_REVISION,
+    }
+    return {**value, "fingerprint": digest(value)}

mlx/src/solomon_mlx/budget.py

@@ -0,0 +1,71 @@
+"""Fail-closed local cost reservations for serialized Modal reference jobs."""
+
+import fcntl
+import json
+import math
+import os
+import time
+import uuid
+from contextlib import contextmanager
+from pathlib import Path
+
+
+class Budget:
+    def __init__(self, path, cap=250.0):
+        self.path, self.cap = Path(path), cap
+        if not math.isfinite(cap) or not 0 < cap <= 250:
+            raise ValueError("The authorized cap is at most US$250")
+
+    @contextmanager
+    def reserve(self, amount, label):
+        if not math.isfinite(amount) or amount <= 0:
+            raise ValueError("Positive finite reservation required")
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with self.path.with_suffix(".lock").open("a") as lock:
+            # Held until the synchronous remote call finishes. Refuse concurrent jobs.
+            try:
+                fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except BlockingIOError:
+                raise RuntimeError("Another reference job already owns the GPU budget") from None
+            ledger = (
+                json.loads(self.path.read_text()) if self.path.exists() else {"cap": self.cap, "entries": []}
+            )
+            if ledger["cap"] != self.cap:
+                raise ValueError("Budget cap changed")
+            if any(e["status"] == "reserved" for e in ledger["entries"]):
+                raise RuntimeError(
+                    "Unresolved prior dispatch: reconcile its remote status before another GPU job"
+                )
+            if any(
+                type(e.get("reserved_usd")) not in (int, float)
+                or not math.isfinite(e["reserved_usd"])
+                or e["reserved_usd"] <= 0
+                or e.get("status") not in ("reserved", "completed_conservative_charge")
+                for e in ledger["entries"]
+            ):
+                raise ValueError("Corrupt budget ledger")
+            used = sum(e["reserved_usd"] for e in ledger["entries"])
+            if used + amount > self.cap:
+                raise RuntimeError("Modal budget exhausted before dispatch")
+            entry = {
+                "id": uuid.uuid4().hex,
+                "label": label,
+                "reserved_usd": amount,
+                "status": "reserved",
+                "time": time.time(),
+            }
+            ledger["entries"].append(entry)
+            self._write(ledger)
+            # If interrupted, leave the reservation unresolved.
+            yield entry
+            entry["status"] = "completed_conservative_charge"
+            entry["completed"] = time.time()
+            self._write(ledger)
+
+    def _write(self, value):
+        tmp = self.path.with_suffix(".tmp")
+        with tmp.open("w") as file:
+            file.write(json.dumps(value, indent=2))
+            file.flush()
+            os.fsync(file.fileno())
+        tmp.replace(self.path)

mlx/src/solomon_mlx/cli.py

@@ -0,0 +1,76 @@
+import argparse
+import json
+from pathlib import Path
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Private Solomon BF16 MLX tooling")
+    commands = parser.add_subparsers(dest="command", required=True)
+    verify = commands.add_parser("verify-source")
+    verify.add_argument("directory")
+    download = commands.add_parser("download-base")
+    download.add_argument("--output", default="snapshots/base")
+    convert = commands.add_parser("prepare")
+    convert.add_argument("--base", default="snapshots/base")
+    convert.add_argument("--solomon", default="snapshots/solomon")
+    convert.add_argument("--manifest", default="snapshots/base-manifest.json")
+    convert.add_argument("--output", default="models/quality")
+    decide = commands.add_parser("decide")
+    decide.add_argument("--model", default="models/quality")
+    decide.add_argument("--document", required=True)
+    decide.add_argument("--questions", required=True)
+    decide.add_argument(
+        "--evidence", choices=["none", "support", "sufficiency", "removal"], default="support"
+    )
+    args = parser.parse_args()
+    if args.command == "verify-source":
+        from .artifacts import verify_release
+
+        print(json.dumps(verify_release(args.directory), indent=2))
+    elif args.command == "download-base":
+        from huggingface_hub import HfApi, snapshot_download
+
+        from .artifacts import BASE_REVISION
+        from .prepare import verify_base
+
+        model = HfApi().model_info("Qwen/Qwen3.8-27B", revision=BASE_REVISION, files_metadata=True)
+        manifest = {
+            "revision": model.sha,
+            "files": [
+                {
+                    "name": f.rfilename,
+                    "size": f.size,
+                    "blob_id": f.blob_id,
+                    "sha256": f.lfs.sha256 if f.lfs else None,
+                }
+                for f in model.siblings
+            ],
+        }
+        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
+        Path(args.output + "-manifest.json").write_text(json.dumps(manifest, indent=2))
+        snapshot_download("Qwen/Qwen3.8-27B", revision=BASE_REVISION, local_dir=args.output, max_workers=18)
+        verified = verify_base(args.output, manifest)
+        Path(args.output + "-verified.json").write_text(json.dumps(verified, indent=2))
+    elif args.command == "prepare":
+        from .prepare import prepare
+
+        prepare(args.base, args.solomon, args.output, args.manifest)
+    else:
+        from .api import Solomon
+
+        model = Solomon.load(args.model)
+        with model.prefill(Path(args.document).read_text()) as state:
+            print(
+                json.dumps(
+                    model.decide(
+                        state=state,
+                        questions=json.loads(Path(args.questions).read_text()),
+                        evidence=args.evidence,
+                    ),
+                    indent=2,
+                )
+            )
+
+
+if __name__ == "__main__":
+    main()

mlx/src/solomon_mlx/engine.py

@@ -0,0 +1,333 @@
+"""BF16 Metal execution with instance-owned adaptation and isolated question caches."""
+
+import copy
+import json
+import threading
+import time
+from pathlib import Path
+
+import mlx.core as mx
+import numpy as np
+from mlx import nn
+from PIL import Image
+
+from ._vendor.prompts import PAGE, SYSTEM
+from .artifacts import ADAPTER_SHA, BASE_REVISION, HEADS_SHA, SOLOMON_REVISION, runtime_identity, sha256
+
+
+class SwitchLoRA(nn.Module):
+    def __init__(self, linear, a, b, context):
+        super().__init__()
+        self.linear, self.lora_a, self.lora_b = linear, a, b
+        self._context = context
+
+    def __call__(self, x):
+        y = self.linear(x)
+        start = self._context["start"]
+        if start is None or start >= x.shape[1]:
+            return y
+        delta = (2.0 * ((x[:, start:].astype(mx.float32) @ self.lora_a) @ self.lora_b)).astype(y.dtype)
+        return y + delta if start == 0 else mx.concatenate([y[:, :start], y[:, start:] + delta], axis=1)
+
+
+def fork_cache(caches):
+    """New cache containers and array handles; MLX owns copy-on-write storage.
+
+    mx.array creates a distinct handle, so slice updates cannot change a prefix's
+    Python array. Recurrent/window updates replace the branch's private slots.
+    """
+    from mlx_vlm.models.cache import ArraysCache, KVCache
+
+    result = []
+    for original in caches:
+        if isinstance(original, ArraysCache):
+            branch = ArraysCache(len(original.cache))
+            branch.cache = [None if x is None else mx.array(x) for x in original.cache]
+        elif isinstance(original, KVCache):
+            branch = KVCache()
+            branch.state = tuple(None if x is None else mx.array(x) for x in original.state)
+        else:
+            raise TypeError(f"Unsupported prefix cache: {type(original).__name__}")
+        result.append(branch)
+    return result
+
+
+class Engine:
+    def __init__(self, directory, *, chunk_size=2048, max_tokens=40960):
+        from mlx_vlm.models.qwen3_vl.processing_qwen3_vl import Qwen3VLProcessor
+        from mlx_vlm.utils import load_model
+
+        self.directory = Path(directory).resolve()
+        self.binding = json.loads((self.directory / "binding.json").read_text())
+        if (
+            self.binding.get("schema") != "solomon-mlx-binding-v1"
+            or self.binding.get("base_revision") != BASE_REVISION
+            or self.binding.get("solomon_revision") != SOLOMON_REVISION
+        ):
+            raise ValueError("Unrecognized or unpinned Solomon MLX binding")
+        if self.binding["profile"] != "quality" or self.binding["dtype"] != "bfloat16":
+            raise ValueError("This runtime currently accepts only the BF16 quality profile")
+        for name, expected in self.binding["files"].items():
+            path = (self.directory / name).resolve()
+            if not path.is_relative_to(self.directory) or sha256(path) != expected:
+                raise ValueError(f"Model artifact checksum mismatch: {name}")
+        adapter, heads = self.directory / "adapter.safetensors", self.directory / "heads.npz"
+        if sha256(adapter) != ADAPTER_SHA or sha256(heads) != HEADS_SHA:
+            raise ValueError("Solomon checkpoint identity mismatch")
+        if not 1 <= chunk_size <= 2048 or not 1 <= max_tokens <= 40960:
+            raise ValueError("Invalid chunk size or context ceiling")
+        weight_bytes = sum(
+            (self.directory / name).stat().st_size
+            for name in self.binding["files"]
+            if name.endswith((".safetensors", ".npz"))
+        )
+        if weight_bytes + 4 * 2**30 > mx.device_info()["max_recommended_working_set_size"]:
+            raise MemoryError(
+                "Full BF16 weights and minimum workspace exceed this Mac’s recommended Metal working set"
+            )
+        self.chunk_size, self.max_tokens = chunk_size, max_tokens
+        self.lock = threading.RLock()
+        self.context = {"start": None}
+        self.model = load_model(self.directory / "backbone", lazy=True, strict=True)
+        self.processor = Qwen3VLProcessor.from_pretrained(
+            str(self.directory / "backbone"), trust_remote_code=False
+        )
+        self.lm, self.t = self.model.language_model, self.processor.tokenizer
+        self.pad = self.t.convert_tokens_to_ids("<|image_pad|>")
+        weights = mx.load(str(adapter))
+        for name in sorted({key.rsplit(".", 1)[0] for key in weights}):
+            parts = name.split(".")
+            if parts[:2] != ["model", "layers"]:
+                raise ValueError(f"Unexpected adapter target: {name}")
+            owner = self.lm.model.layers[int(parts[2])]
+            for part in parts[3:-1]:
+                owner = getattr(owner, part)
+            linear = getattr(owner, parts[-1])
+            a, b = weights[name + ".lora_a"].astype(mx.float32), weights[name + ".lora_b"].astype(mx.float32)
+            if a.shape != (linear.weight.shape[1], 64) or b.shape != (64, linear.weight.shape[0]):
+                raise ValueError(f"Adapter orientation/shape mismatch: {name}")
+            setattr(owner, parts[-1], SwitchLoRA(linear, a, b, self.context))
+        with np.load(heads, allow_pickle=False) as archive:
+            keys = {k[:-7] for k in archive.files if k.endswith("/weight")}
+            required_heads = {
+                "boolean/state4",
+                "entity/state4",
+                "multilabel/state4",
+                "ordered/threshold4",
+                "single/choiceR",
+                "single/choiceS",
+                "single/sufficiency3",
+                "ordered/choiceR",
+                "ordered/choiceS",
+                "ordered/sufficiency3",
+            }
+            if keys != required_heads:
+                raise ValueError("All ten semantic heads are required")
+            self.heads = {}
+            for key in keys:
+                w, b = archive[key + "/weight"], archive[key + "/bias"]
+                if (
+                    w.shape != (10, 5120)
+                    or b.shape != (10,)
+                    or not np.isfinite(w).all()
+                    or not np.isfinite(b).all()
+                ):
+                    raise ValueError("Invalid semantic head")
+                self.heads[key] = (mx.array(w, mx.float32), mx.array(b, mx.float32))
+        self.model.freeze()
+        self.model.eval()
+        mx.eval(self.model.parameters(), self.heads)
+        self.identity = runtime_identity(self.binding, chunk_size=self.chunk_size, max_tokens=self.max_tokens)
+
+    def render(self, parts, block):
+        content = ""
+        for i, p in enumerate(parts):
+            if "text" in p:
+                content += ("\n" if i and "image" in parts[i - 1] else "") + p["text"]
+            else:
+                content += ("\n" if i and "text" in parts[i - 1] else "") + PAGE
+        return self.t.apply_chat_template(
+            [
+                {"role": "system", "content": SYSTEM},
+                {"role": "user", "content": "Document:\n" + content + "\n\n" + block},
+            ],
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+
+    def expand(self, ids, counts):
+        out, index = [], 0
+        for token in ids:
+            if token == self.pad:
+                if index >= len(counts):
+                    raise ValueError("Unexpected image placeholder in document text")
+                out.extend([token] * counts[index])
+                index += 1
+            else:
+                out.append(token)
+        if index != len(counts):
+            raise ValueError("Image placeholder count mismatch")
+        return out
+
+    def positions(self, start, count):
+        return mx.broadcast_to(mx.arange(start, start + count)[None, None, :], (3, 1, count))
+
+    def admit(self, count):
+        if count < 1 or count > self.max_tokens:
+            raise ValueError(f"{count} tokens exceeds the {self.max_tokens}-token scope ceiling")
+        # Conservative allowance: BF16 attention KV + FP32 recurrent states and
+        # chunk intermediates. This supplements the token ceiling, not a promise
+        # of availability in the presence of other processes.
+        temporary = 4 * 2**30 + count * 16 * 2 * 4 * 256 * 2
+        limit = mx.device_info()["max_recommended_working_set_size"]
+        if mx.get_active_memory() + temporary > limit:
+            raise MemoryError("Insufficient recommended Metal working set for this request")
+
+    def forward(self, ids, positions, cache, *, embeds=None, adapter_from=None, taps=()):
+        hidden, captured = None, {}
+        try:
+            for start in range(0, len(ids), self.chunk_size):
+                end = min(start + self.chunk_size, len(ids))
+                self.context["start"] = None if adapter_from is None else max(0, adapter_from - start)
+                last = end == len(ids)
+                out = self.lm(
+                    mx.array([ids[start:end]]),
+                    cache=cache,
+                    position_ids=positions[:, :, start:end],
+                    inputs_embeds=None if embeds is None else embeds[:, start:end],
+                    skip_logits=True,
+                    return_hidden=last,
+                    capture_layer_ids=list(taps) if last else None,
+                )
+                if last:
+                    hidden = out.hidden_states[-1][0, -1].astype(mx.float32)
+                    captured = {
+                        str(i): self.lm.model.norm(h[:, -1:])[0, -1].astype(mx.float32)
+                        for i, h in zip(sorted(set(taps)), out.hidden_states[:-1])
+                    }
+                    mx.eval(hidden, captured)
+                mx.eval([c.state for c in cache])
+            return hidden, captured
+        finally:
+            self.context["start"] = None
+
+    def prefill(self, parts):
+        with self.lock:
+            prefill_started = time.perf_counter()
+            text = self.render(parts, "X")
+            boundary = text.rfind("\n\nX")
+            if boundary < 0:
+                raise ValueError("Missing document boundary")
+            raw = self.t.encode(text[:boundary], add_special_tokens=False)
+            if "text" in parts[-1]:
+                raw = raw[:-1]
+            vision_started = time.perf_counter()
+            counts, grids, features = [], [], []
+            for part in parts:
+                if "image" not in part:
+                    continue
+                with Image.open(part["image"]) as image:
+                    processed = self.processor.image_processor(images=[image.convert("RGB")])
+                grid_np = np.asarray(processed["image_grid_thw"])
+                count = int(grid_np.prod()) // self.model.config.vision_config.spatial_merge_size**2
+                self.admit(len(raw) + sum(counts) + count - len(counts) - 1)
+                grid = mx.array(grid_np)
+                pixels = mx.array(np.asarray(processed["pixel_values"])).astype(
+                    self.model.vision_tower.patch_embed.proj.weight.dtype
+                )
+                feature, _ = self.model.vision_tower(pixels, grid)
+                mx.eval(feature)
+                counts.append(count)
+                grids.append(grid)
+                features.append(feature)
+            vision_seconds = time.perf_counter() - vision_started if counts else 0.0
+            ids = self.expand(raw, counts)
+            self.admit(len(ids))
+            embeds, delta, feats, grid = None, 0, None, None
+            if counts:
+                feats, grid = mx.concatenate(features), mx.concatenate(grids)
+                f = self.model.get_input_embeddings(
+                    mx.array([ids]), mx.zeros((1,)), image_grid_thw=grid, cached_image_features=feats
+                )
+                embeds, positions = f.inputs_embeds, f.position_ids
+                delta = int(np.asarray(f.rope_deltas).reshape(-1)[0])
+                if delta != int(mx.max(positions).item()) + 1 - len(ids):
+                    raise ValueError("Multimodal RoPE offset mismatch")
+            else:
+                positions = self.positions(0, len(ids))
+            cache = self.lm.make_cache()
+            started = time.perf_counter()
+            self.forward(ids, positions, cache, embeds=embeds)
+            return {
+                "parts": copy.deepcopy(parts),
+                "prefix_ids": ids,
+                "cache": cache,
+                "counts": counts,
+                "rope_delta": delta,
+                "features": feats,
+                "grid": grid,
+                "positions": positions,
+                "prefill_seconds": time.perf_counter() - prefill_started,
+                "language_prefill_seconds": time.perf_counter() - started,
+                "vision_seconds": vision_seconds,
+            }
+
+    def ask(self, state, block, width, head, *, execution="cached", taps=()):
+        with self.lock:
+            if head not in self.heads or not 2 <= width <= 10:
+                raise ValueError("Unknown semantic head or invalid width")
+            ids = self.expand(
+                self.t.encode(self.render(state["parts"], block), add_special_tokens=False), state["counts"]
+            )
+            self.admit(len(ids))
+            p = len(state["prefix_ids"])
+            if ids[:p] != state["prefix_ids"]:
+                raise ValueError("Question token prefix differs from cached document")
+            started = time.perf_counter()
+            if execution == "cached":
+                hidden, captured = self.forward(
+                    ids[p:],
+                    self.positions(p + state["rope_delta"], len(ids) - p),
+                    fork_cache(state["cache"]),
+                    adapter_from=0,
+                    taps=taps,
+                )
+            elif execution == "full":
+                embeds = None
+                if state["counts"]:
+                    f = self.model.get_input_embeddings(
+                        mx.array([ids]),
+                        mx.zeros((1,)),
+                        image_grid_thw=state["grid"],
+                        cached_image_features=state["features"],
+                    )
+                    embeds, positions = f.inputs_embeds, f.position_ids
+                else:
+                    positions = self.positions(0, len(ids))
+                hidden, captured = self.forward(
+                    ids, positions, self.lm.make_cache(), embeds=embeds, adapter_from=p, taps=taps
+                )
+            else:
+                raise ValueError("Execution must be cached or full")
+            w, b = self.heads[head]
+            logits = (w @ hidden + b)[:width]
+            mx.eval(logits)
+            values = np.asarray(logits)
+            if not np.isfinite(values).all():
+                raise ValueError("Nonfinite trained-head output")
+            result = {
+                "letter_logits": values.tolist(),
+                "head_key": head,
+                "prompt_tokens": len(ids),
+                "branch_tokens": len(ids) - p,
+                "reused_prefix_tokens": p if execution == "cached" else 0,
+                "seconds": time.perf_counter() - started,
+            }
+            if taps:
+                result.update(
+                    hidden=np.asarray(hidden).tolist(),
+                    taps={k: np.asarray(v).tolist() for k, v in captured.items()},
+                    token_ids=ids,
+                )
+            return result

mlx/src/solomon_mlx/evaluation.py

@@ -0,0 +1,324 @@
+"""Resumable panel scoring, fit-only calibration and one-shot held-out reports."""
+
+import gzip
+import hashlib
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+from scipy.optimize import minimize_scalar
+
+from ._vendor.semantics import listed_probs, p_yes
+from .api import TASKS
+from .artifacts import ADAPTER_SHA, HEADS_SHA, digest, sha256
+
+
+def load_panel(directory):
+    directory = Path(directory)
+    manifest = json.loads((directory / "manifest.json").read_text())
+    if (
+        manifest["adapter_sha256"] != ADAPTER_SHA
+        or manifest["heads_sha256"] != HEADS_SHA
+        or manifest["readout_mode"] != "four_collapsed"
+    ):
+        raise ValueError("Panel belongs to a different checkpoint or answer semantics")
+    raw = gzip.decompress((directory / "jobs.json.gz").read_bytes())
+    if hashlib.sha256(raw).hexdigest() != manifest["jobs_sha256"]:
+        raise ValueError("Panel jobs checksum mismatch")
+    jobs = json.loads(raw)
+    if len({r["id"] for r in jobs}) != len(jobs):
+        raise ValueError("Duplicate panel branch IDs")
+    return jobs, manifest
+
+
+def score_panel(model, panel, output):
+    """Atomically persist each document so interruption never requires rescoring it."""
+    jobs, manifest = load_panel(panel)
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+    identity = {
+        "runtime": model.identity,
+        "panel_sha256": manifest["jobs_sha256"],
+        "panel_role": Path(panel).name.split("-")[0],
+    }
+    meta = output / "identity.json"
+    if meta.exists() and json.loads(meta.read_text()) != identity:
+        raise ValueError("Cannot resume with different model code, weights or panel")
+    meta.write_text(json.dumps(identity, indent=2))
+    documents = defaultdict(list)
+    for row in jobs:
+        documents[row["document_key"]].append(row)
+    for key, group in documents.items():
+        path = output / (key + ".json")
+        if path.exists():
+            record = json.loads(path.read_text())
+            body = {k: v for k, v in record.items() if k != "sha256"}
+            if (
+                record["sha256"] != digest(body)
+                or record["identity"] != digest(identity)
+                or [r["id"] for r in record["rows"]] != [r["id"] for r in group]
+            ):
+                raise ValueError("Corrupt or mismatched resumed document")
+            continue
+        parts = group[0].get("parts") or [{"text": group[0]["doc"]}]
+        if any((r.get("parts") or [{"text": r["doc"]}]) != parts for r in group):
+            raise ValueError("Document key aliases different sources")
+        with model.prefill(parts) as state:
+            rows = []
+            for job in group:
+                result = model.engine.ask(state._data, job["block"], job["n"], job["head_key"])
+                rows.append({**result, **{k: job[k] for k in ("id", "task", "gold", "n", "question_id")}})
+            body = {
+                "identity": digest(identity),
+                "rows": rows,
+                "prefix_tokens": state.prefix_tokens,
+                "prefill_seconds": state._data["prefill_seconds"],
+            }
+        temp = path.with_suffix(".tmp")
+        temp.write_text(json.dumps({**body, "sha256": digest(body)}))
+        temp.replace(path)
+        print("Scored " + key + " " + str(len(rows)) + " branches", flush=True)
+    completed = {
+        "identity": digest(identity),
+        "documents": len(documents),
+        "branches": len(jobs),
+        "files": {key + ".json": sha256(output / (key + ".json")) for key in documents},
+    }
+    (output / "complete.json").write_text(json.dumps(completed, indent=2))
+
+
+def read_scores(directory):
+    directory = Path(directory)
+    identity = json.loads((directory / "identity.json").read_text())
+    completed = json.loads((directory / "complete.json").read_text())
+    if completed["identity"] != digest(identity):
+        raise ValueError("Score identity mismatch")
+    rows = []
+    for name, checksum in completed["files"].items():
+        p = directory / name
+        if not p.resolve().is_relative_to(directory.resolve()) or sha256(p) != checksum:
+            raise ValueError("Score checksum mismatch")
+        record = json.loads(p.read_text())
+        rows.extend(record["rows"])
+    if len(rows) != completed["branches"]:
+        raise ValueError("Incomplete score set")
+    return rows, identity
+
+
+def unit(row, temperature=1.0):
+    logits = row["letter_logits"]
+    task = row["task"]
+    gold = row["gold"]
+    if task in ("boolean", "entity", "multilabel"):
+        p = p_yes(logits, temperature)
+        return [1 - p, p], int(gold == 0)
+    width = row["n"] - 2 if row["head_key"].endswith("choiceR") else row["n"]
+    if not isinstance(gold, int) or not 0 <= gold < width:
+        return None, None
+    return listed_probs(logits, width, temperature).tolist(), gold
+
+
+def fit_calibration(scores, output, *, panel_role):
+    if panel_role != "fit":
+        raise ValueError("Temperature fitting accepts fit panels only")
+    rows, identity = read_scores(scores)
+    if identity["panel_role"] != "fit":
+        raise ValueError("Scores were not generated from a fit panel")
+    output = Path(output)
+    if output.exists():
+        raise FileExistsError("Calibration artifacts are immutable")
+    temperatures, losses = {}, {}
+    for task in TASKS:
+        selected = [r for r in rows if r["task"] == task and unit(r)[0] is not None]
+        if not selected:
+            raise ValueError("No fit examples for " + task)
+
+        def loss(log_t, selected=selected):
+            t = float(np.exp(log_t))
+            return float(np.mean([-np.log(max(unit(r, t)[0][unit(r, t)[1]], 1e-300)) for r in selected]))
+
+        fit = minimize_scalar(loss, bounds=(np.log(0.05), np.log(20)), method="bounded")
+        temperatures[task] = float(np.exp(fit.x))
+        losses[task] = {"before": loss(0.0), "after": float(fit.fun), "units": len(selected)}
+    payload = {
+        "schema": "solomon-mlx-temperature-v1",
+        "runtime": identity["runtime"]["fingerprint"],
+        "temperatures": temperatures,
+        "fit_panel_sha256": identity["panel_sha256"],
+        "losses": losses,
+        "selection_role": "fit",
+        "heldout_used": False,
+    }
+    output.write_text(json.dumps({**payload, "sha256": digest(payload)}, indent=2))
+    return payload
+
+
+def compare_rows(mlx_rows, cuda_rows, *, temperatures=None, reference_temperatures=None):
+    temperatures = temperatures or dict.fromkeys(TASKS, 1.0)
+    reference_temperatures = reference_temperatures or dict.fromkeys(TASKS, 1.0)
+    reference = {r["id"]: r for r in cuda_rows}
+    if len(reference) != len(cuda_rows) or set(reference) != {r["id"] for r in mlx_rows}:
+        raise ValueError("Comparison panels have different or duplicate branch IDs")
+    units = []
+    questions = defaultdict(list)
+    for row in mlx_rows:
+        other = {**row, "letter_logits": reference[row["id"]]["letter_logits"]}
+        p, gold = unit(row, temperatures[row["task"]])
+        q, _ = unit(other, reference_temperatures[row["task"]])
+        if p is None:
+            continue
+        left, right = int(np.argmax(p)), int(np.argmax(q))
+        item = {
+            "agreement": left == right,
+            "mlx_correct": left == gold,
+            "cuda_correct": right == gold,
+            "probability_drift": float(np.max(np.abs(np.asarray(p) - q))),
+        }
+        units.append(item)
+        questions[row["question_id"]].append(item)
+    if not units:
+        raise ValueError("No defined comparison targets")
+    agreement = float(np.mean([r["agreement"] for r in units]))
+    question_agreement = float(np.mean([all(x["agreement"] for x in r) for r in questions.values()]))
+    mlx_accuracy = float(np.mean([all(x["mlx_correct"] for x in r) for r in questions.values()]))
+    cuda_accuracy = float(np.mean([all(x["cuda_correct"] for x in r) for r in questions.values()]))
+    return {
+        "units": len(units),
+        "questions": len(questions),
+        "unit_decision_agreement": agreement,
+        "question_decision_agreement": float(
+            np.mean([all(x["agreement"] for x in r) for r in questions.values()])
+        ),
+        "mlx_whole_question_accuracy": mlx_accuracy,
+        "cuda_whole_question_accuracy": cuda_accuracy,
+        "accuracy_degradation_percentage_points": 100 * (cuda_accuracy - mlx_accuracy),
+        "max_probability_drift": max(r["probability_drift"] for r in units),
+        "probability_comparison": {
+            "mlx_temperatures": temperatures,
+            "cuda_temperatures": reference_temperatures,
+        },
+        "mean_probability_drift": float(np.mean([r["probability_drift"] for r in units])),
+        "quality_gate_passed": agreement >= 0.999
+        and question_agreement >= 0.999
+        and cuda_accuracy - mlx_accuracy <= 0.0025,
+    }
+
+
+def read_cuda_scores(directory, panel, reference_identity):
+    """Reuse only scores bound to the exact pinned CUDA runtime and panel."""
+    jobs, manifest = load_panel(panel)
+    directory = Path(directory)
+    result = {}
+    for file in sorted(directory.glob("scores*.json.gz")):
+        payload = json.loads(gzip.decompress(file.read_bytes()))
+        identity = payload["identity"]
+        if not payload["complete"] or identity["runtime"] != reference_identity:
+            raise ValueError("Existing CUDA scores do not match the fresh reference runtime")
+        if identity["manifest"]["jobs_sha256"] != manifest["jobs_sha256"]:
+            raise ValueError("CUDA scores use another panel")
+        for key, row in payload["scores"].items():
+            if key in result:
+                raise ValueError("Duplicate CUDA score ID")
+            result[key] = row
+    if set(result) != {r["id"] for r in jobs}:
+        raise ValueError("CUDA score set is incomplete")
+    return [{**r, **result[r["id"]]} for r in jobs]
+
+
+def select_calibration(fitted, dev_scores, output):
+    fitted, output = Path(fitted), Path(output)
+    if output.exists():
+        raise FileExistsError("Selected calibration is immutable")
+    fit = json.loads(fitted.read_text())
+    fit_payload = {k: v for k, v in fit.items() if k != "sha256"}
+    rows, identity = read_scores(dev_scores)
+    if (
+        fit["sha256"] != digest(fit_payload)
+        or identity["runtime"]["fingerprint"] != fit["runtime"]
+        or identity["panel_role"] != "dev"
+    ):
+        raise ValueError("Calibration or development identity mismatch")
+    temperatures, selection = {}, {}
+    for task in TASKS:
+        selected = [r for r in rows if r["task"] == task and unit(r)[0] is not None]
+        if not selected:
+            raise ValueError("Missing development task " + task)
+
+        def loss(t, selected=selected):
+            values = [unit(r, t) for r in selected]
+            return float(np.mean([-np.log(max(p[g], 1e-300)) for p, g in values]))
+
+        original, candidate = loss(1.0), loss(fit["temperatures"][task])
+        temperatures[task] = fit["temperatures"][task] if candidate < original else 1.0
+        selection[task] = {"untempered_nll": original, "fit_temperature_nll": candidate}
+    payload = {
+        **fit_payload,
+        "temperatures": temperatures,
+        "selection_role": "dev_selected",
+        "fit_artifact_sha256": sha256(fitted),
+        "dev_panel_sha256": identity["panel_sha256"],
+        "development_selection": selection,
+    }
+    output.write_text(json.dumps({**payload, "sha256": digest(payload)}, indent=2))
+    return payload
+
+
+def heldout_report(
+    scores,
+    cuda_directory,
+    panel,
+    calibration,
+    reference,
+    output,
+    *,
+    reference_binding="evaluations/cuda-acceptance/input/serving-binding.json",
+):
+    """Evaluate a frozen configuration once; an existing output cannot be replaced."""
+    output = Path(output)
+    if output.exists():
+        raise FileExistsError("Held-out report already exists; do not reuse it for selection")
+    rows, identity = read_scores(scores)
+    cal = json.loads(Path(calibration).read_text())
+    payload = {k: v for k, v in cal.items() if k != "sha256"}
+    if (
+        cal["sha256"] != digest(payload)
+        or cal["runtime"] != identity["runtime"]["fingerprint"]
+        or cal["selection_role"] != "dev_selected"
+        or identity["panel_role"] != "cert"
+    ):
+        raise ValueError(
+            "Held-out evaluation requires frozen development-selected calibration and cert scores"
+        )
+    ref = json.loads(Path(reference).read_text())
+    cuda = read_cuda_scores(cuda_directory, panel, ref["identity"])
+    binding_path = Path(reference_binding)
+    source_manifest = json.loads((binding_path.parent / "manifest.json").read_text())
+    if sha256(binding_path) != source_manifest["files"][binding_path.name]:
+        raise ValueError("CUDA acceptance binding checksum mismatch")
+    binding = json.loads(binding_path.read_text())
+    for key in (
+        "adapter_sha256",
+        "trained_heads_sha256",
+        "model_sha256",
+        "numerics",
+        "placement",
+        "arithmetic",
+    ):
+        if binding["runtime"][key] != ref["identity"][key]:
+            raise ValueError("CUDA calibration belongs to another reference runtime")
+    reference_temperatures = {task: binding["temperatures"]["models"][task]["temperature"] for task in TASKS}
+    report = {
+        **compare_rows(
+            rows, cuda, temperatures=cal["temperatures"], reference_temperatures=reference_temperatures
+        ),
+        "cuda_calibration_binding_sha256": sha256(binding_path),
+        "runtime": identity["runtime"],
+        "panel_sha256": identity["panel_sha256"],
+        "calibration_sha256": sha256(calibration),
+        "reference_sha256": sha256(reference),
+        "scope": "text-only held-out panel",
+        "image_qualification": False,
+    }
+    output.write_text(json.dumps(report, indent=2))
+    return report

mlx/src/solomon_mlx/prepare.py

@@ -0,0 +1,121 @@
+"""Verify immutable input snapshots and create a separately checksummed BF16 model."""
+
+import hashlib
+import json
+import shutil
+from importlib.metadata import version
+from pathlib import Path
+
+from .artifacts import BASE_REVISION, SOLOMON_REVISION, sha256, verify_release
+
+
+def verify_base(root, manifest):
+    root = Path(root)
+    if manifest["revision"] != BASE_REVISION:
+        raise ValueError("Wrong pinned base revision")
+    result = {}
+    for row in manifest["files"]:
+        path = root / row["name"]
+        if not path.resolve().is_relative_to(root.resolve()):
+            raise ValueError("Unsafe base manifest path")
+        if path.stat().st_size != row["size"]:
+            raise ValueError("Base size mismatch: " + row["name"])
+        actual = sha256(path)
+        if row["sha256"]:
+            if actual != row["sha256"]:
+                raise ValueError("Base checksum mismatch: " + row["name"])
+        else:
+            data = path.read_bytes()
+            git_hash = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest()
+            if git_hash != row["blob_id"]:
+                raise ValueError("Base Git blob mismatch: " + row["name"])
+        result[row["name"]] = actual
+    return result
+
+
+def prepare(base, solomon, output, manifest):
+
+    base, solomon, output = map(Path, (base, solomon, output))
+    source_hashes = verify_release(solomon)
+    base_hashes = verify_base(base, json.loads(Path(manifest).read_text()))
+    if output.exists():
+        raise FileExistsError("Use a new output directory; existing conversions are immutable")
+    output.mkdir(parents=True)
+    convert_bf16(base, output / "backbone")
+    shutil.copy2(solomon / "adapter/adapter.safetensors", output / "adapter.safetensors")
+    shutil.copy2(solomon / "adapter/heads.npz", output / "heads.npz")
+    for name in ("LICENSE", "NOTICE", "MODIFICATIONS.md"):
+        shutil.copy2(solomon / name, output / name)
+    files = {
+        str(p.relative_to(output)): sha256(p)
+        for p in sorted(output.rglob("*"))
+        if p.is_file() and ".cache" not in p.parts
+    }
+    binding = {
+        "schema": "solomon-mlx-binding-v1",
+        "profile": "quality",
+        "dtype": "bfloat16",
+        "adapter_dtype": "float32",
+        "head_dtype": "float32",
+        "recurrent_state_dtype": "float32",
+        "sensitive_parameters": "FP32 normalization weights, A_log and dt_bias",
+        "conversion": "upstream Qwen3.5 sanitization, norms promoted before unit offset",
+        "adapter_scale": 2.0,
+        "adapter_placement": "question",
+        "quantization": None,
+        "base_revision": BASE_REVISION,
+        "solomon_revision": SOLOMON_REVISION,
+        "source_hashes": source_hashes,
+        "base_hashes": base_hashes,
+        "dependencies": {p: version(p) for p in ("mlx", "mlx-vlm", "transformers", "numpy")},
+        "files": files,
+    }
+    (output / "binding.json").write_text(json.dumps(binding, indent=2, sort_keys=True))
+    return binding
+
+
+def convert_bf16(base, output):
+    """Convert one original shard at a time; never copy download caches.
+
+    Keep normalization offsets in FP32 before adding one. Adding the unit
+    offset in BF16 would irreversibly round trained normalization parameters.
+    Large backbone matrices remain unquantized BF16.
+    """
+    import mlx.core as mx
+    from mlx.utils import tree_flatten
+    from mlx_vlm.models.qwen3_5.config import ModelConfig
+    from mlx_vlm.models.qwen3_5.qwen3_5 import Model
+
+    base, output = Path(base), Path(output)
+    output.mkdir(parents=True, exist_ok=False)
+    config = json.loads((base / "config.json").read_text())
+    if config.get("model_type") != "qwen3_5" or config.get("quantization"):
+        raise ValueError("Expected original unquantized Qwen3.5 architecture")
+    model = Model(ModelConfig.from_dict(config))
+    expected = {k: v.shape for k, v in tree_flatten(model.parameters())}
+    index = {"metadata": {"total_size": 0}, "weight_map": {}}
+    source_index = json.loads((base / "model.safetensors.index.json").read_text())
+    for filename in sorted(set(source_index["weight_map"].values())):
+        arrays = mx.load(str(base / filename))
+        for key, value in arrays.items():
+            sensitive = value.ndim == 1 and ("norm" in key or key.endswith(("A_log", "dt_bias")))
+            arrays[key] = value.astype(mx.float32 if sensitive else mx.bfloat16)
+        arrays = model.sanitize(arrays)
+        arrays = model.vision_tower.sanitize(arrays)
+        for key, value in arrays.items():
+            if key not in expected or value.shape != expected[key]:
+                raise ValueError("Converted tensor shape mismatch: " + key)
+            if key in index["weight_map"]:
+                raise ValueError("Duplicate converted tensor: " + key)
+            index["weight_map"][key] = filename
+            index["metadata"]["total_size"] += value.nbytes
+        mx.save_safetensors(str(output / filename), arrays, metadata={"format": "mlx"})
+        del arrays
+        mx.clear_cache()
+        print("Converted " + filename, flush=True)
+    if set(index["weight_map"]) != set(expected):
+        raise ValueError("Converted backbone is missing required parameters")
+    (output / "model.safetensors.index.json").write_text(json.dumps(index, indent=2, sort_keys=True))
+    for file in base.iterdir():
+        if file.is_file() and file.name != "model.safetensors.index.json" and file.suffix != ".safetensors":
+            shutil.copy2(file, output / file.name)

mlx/src/solomon_mlx_hub/__init__.py

@@ -0,0 +1,5 @@
+"""Prepare the adapter-only Hub release for the frozen Solomon MLX runtime."""
+
+from .prepare import load, prepare_from_hub, prepare_from_snapshot, verify_prepared
+
+__all__ = ["load", "prepare_from_hub", "prepare_from_snapshot", "verify_prepared"]

mlx/src/solomon_mlx_hub/__main__.py

@@ -0,0 +1,50 @@
+"""Adapter-only Hub setup and verification command."""
+
+import argparse
+import json
+
+from .prepare import prepare_from_hub, prepare_from_snapshot, verify_prepared
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Prepare full BF16 Solomon from the adapter-only release")
+    commands = parser.add_subparsers(dest="command", required=True)
+    prepare = commands.add_parser("prepare")
+    prepare.add_argument("--revision", required=True, help="Full Solomon repository commit SHA")
+    prepare.add_argument("--output", default="models/quality")
+    prepare.add_argument("--base", help="Existing original Qwen snapshot, already downloaded")
+    prepare.add_argument("--snapshot", help="Existing adapter-only Solomon snapshot; requires --base")
+    prepare.add_argument("--cache-dir")
+    prepare.add_argument("--device", choices=("cpu", "gpu"), default="cpu")
+    verify = commands.add_parser("verify")
+    verify.add_argument("directory")
+    args = parser.parse_args()
+    if args.command == "verify":
+        binding = verify_prepared(args.directory)
+        print(json.dumps({"verified": True, "files": len(binding["files"]), "profile": binding["profile"]}))
+    elif args.snapshot:
+        if not args.base:
+            parser.error("--snapshot requires --base for offline preparation")
+        print(
+            prepare_from_snapshot(
+                args.snapshot,
+                args.output,
+                revision=args.revision,
+                base_dir=args.base,
+                device=args.device,
+            )
+        )
+    else:
+        print(
+            prepare_from_hub(
+                args.output,
+                revision=args.revision,
+                base_dir=args.base,
+                cache_dir=args.cache_dir,
+                device=args.device,
+            )
+        )
+
+
+if __name__ == "__main__":
+    main()

mlx/src/solomon_mlx_hub/data/base-manifest.json

@@ -0,0 +1,197 @@
+{
+  "revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+  "files": [
+    {
+      "name": ".gitattributes",
+      "size": 1570,
+      "blob_id": "52373fe24473b1aa44333d318f578ae6bf04b49b",
+      "sha256": null
+    },
+    {
+      "name": "LICENSE",
+      "size": 11544,
+      "blob_id": "f938136e3adacfd92be087f6e113b5d6d97f678f",
+      "sha256": null
+    },
+    {
+      "name": "README.md",
+      "size": 65012,
+      "blob_id": "bc8aa0e396cd029c21cd773cca21830d0ded28ec",
+      "sha256": null
+    },
+    {
+      "name": "chat_template.jinja",
+      "size": 8952,
+      "blob_id": "c0c686f9c38d70d179fb7b5f5aa7530bc913dda3",
+      "sha256": null
+    },
+    {
+      "name": "config.json",
+      "size": 4312,
+      "blob_id": "706cebd746c4b6f2b1d1f892630867acfdfd3df8",
+      "sha256": null
+    },
+    {
+      "name": "crc32.txt",
+      "size": 238,
+      "blob_id": "6de5ee6a0c6596744baee911af0a5cdcb8d99a1e",
+      "sha256": null
+    },
+    {
+      "name": "generation_config.json",
+      "size": 202,
+      "blob_id": "023756cfadf88e5bf69eefeee3e172f38c448d64",
+      "sha256": null
+    },
+    {
+      "name": "merges.txt",
+      "size": 3353259,
+      "blob_id": "a494e019ca1502219fd0128658b979e5f05ae8e8",
+      "sha256": null
+    },
+    {
+      "name": "model-00001-of-00018.safetensors",
+      "size": 3966730552,
+      "blob_id": "79b73cdd69afeca931d181f5d1e21ad2d73bb7b7",
+      "sha256": "ba0ce20aae489ad196733da5064bcdf159a1fe84f53336648196e1ebb7751b1c"
+    },
+    {
+      "name": "model-00002-of-00018.safetensors",
+      "size": 3043080328,
+      "blob_id": "81cf43545884a227a01351942dfbc72577812316",
+      "sha256": "06a148c01bfbe3faa14a5f184a7ff29a706f7ae1c8b2705d2058e26d17a001fb"
+    },
+    {
+      "name": "model-00003-of-00018.safetensors",
+      "size": 2542796952,
+      "blob_id": "a2da5e6cd6307a6cae13d04820ab0d31b47b48bd",
+      "sha256": "2e1bf62cbcd406eaa64b60d10353e1f0ef4039d0976e56f05cabe953454f9968"
+    },
+    {
+      "name": "model-00004-of-00018.safetensors",
+      "size": 3988973152,
+      "blob_id": "175ddab3f2488ad181f73d789d2d778cf6d4fca6",
+      "sha256": "511e34063187882659753c4d93f3859f93c019fd438d8813071921c81d9a3f1a"
+    },
+    {
+      "name": "model-00005-of-00018.safetensors",
+      "size": 2099339864,
+      "blob_id": "64890208fdd563c3aac0c2f55f69948bcaa1a492",
+      "sha256": "635cb53446dc74f219740fc59e18b774f877b803b9722e289ca62575a6efa701"
+    },
+    {
+      "name": "model-00006-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "3ae29b86e4c773babfe17124dbd10d54d37819ec",
+      "sha256": "0bc5214fac607f0e6cc92eec3789d4b8559410ef9fce66621ba8158e8410dae0"
+    },
+    {
+      "name": "model-00007-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "b7e9c0f038884839f3dad38fef7e75ee3362c24f",
+      "sha256": "80b0c49033e9a0d5762562aa12f4acdb7f54da586f3d0110f28c48d91cf07892"
+    },
+    {
+      "name": "model-00008-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "0b58cbc52714e1c683711be87e7c2e33fb10e7a0",
+      "sha256": "7192c5b66185d3592927daabee1cc19e6f6e0ce75988ee20e824b624765fda79"
+    },
+    {
+      "name": "model-00009-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "4fc0c6b28004d809225d0e115f30e9e11c2345dc",
+      "sha256": "af3c48cc37af44f3db6ae0579baf019180d48d9c527caa0a1f03ff85813a56d8"
+    },
+    {
+      "name": "model-00010-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "9ec693a17c788084116c51b4f34632670df77612",
+      "sha256": "163490a76f3bea3a40855b7efc04ce6d27afaf1a34f0bbde495b9491f76457c9"
+    },
+    {
+      "name": "model-00011-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "3c63baaed16d833432a919647af53ac76bb6b007",
+      "sha256": "5f3ae1b948aeee39da77aec558e8236cd65fe4d7cb7686a76bb007acc563c6d8"
+    },
+    {
+      "name": "model-00012-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "8568b440a4666ed1b4cda0b5d21496378304f326",
+      "sha256": "a3de1c7114677a8f5ac5c4892c90e8238ea5c1e2038c80e757dfc87c3902ca55"
+    },
+    {
+      "name": "model-00013-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "724083995a2257194321a3d00b36fd7d4bb7348d",
+      "sha256": "06ab79a41f74c9c5cb734816feb0c7fc364104b227165ee7391231e1155aa02a"
+    },
+    {
+      "name": "model-00014-of-00018.safetensors",
+      "size": 3979553696,
+      "blob_id": "a60b80b6510d7938d951fbddc76aaadd121c6268",
+      "sha256": "4138ed94603065ba884bbcadedb04d7718bb40117e85e6f5c6fc5b9c05b7a85b"
+    },
+    {
+      "name": "model-00015-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "7d4c34f3d716e1a47acff2f576b65b41a3ec4f3f",
+      "sha256": "69224e27b9de4e7dbf6fc936c6eaae08447bda3b80a6c31a871ab451173afd22"
+    },
+    {
+      "name": "model-00016-of-00018.safetensors",
+      "size": 3979564040,
+      "blob_id": "c67e3e42c9715298fa7f68c6b378bfb1d74290d0",
+      "sha256": "73cb9a1089fb6155cb648609478d6633be8a5c7d9ca5a05bc8925ce8a553cefe"
+    },
+    {
+      "name": "model-00017-of-00018.safetensors",
+      "size": 2108759344,
+      "blob_id": "23dd899179729a4370c655e2c2241cfdbe4ef4ba",
+      "sha256": "beb51f01056142ac4984bd800507b0dd0fd18de57f8e9ef6ea41d1a3598983a8"
+    },
+    {
+      "name": "model-00018-of-00018.safetensors",
+      "size": 3392197344,
+      "blob_id": "a92b4073fc6a58ffc9334ac63360fc8d9cc50d33",
+      "sha256": "1d3479509e21494658f9b64d317f5ea8e55c4025d28c702d6c4d0b356ce8ea06"
+    },
+    {
+      "name": "model.safetensors.index.json",
+      "size": 112216,
+      "blob_id": "da35e3c564457dface7d138f0b6cac284ff8958c",
+      "sha256": null
+    },
+    {
+      "name": "preprocessor_config.json",
+      "size": 390,
+      "blob_id": "2ea84a437d448ff71b08df68fdd949d5cc4ebb64",
+      "sha256": null
+    },
+    {
+      "name": "tokenizer.json",
+      "size": 12809320,
+      "blob_id": "9328ce9c41e80f6dd7bc2c66d8ae1fc93bf87440",
+      "sha256": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3"
+    },
+    {
+      "name": "tokenizer_config.json",
+      "size": 17928,
+      "blob_id": "5de744b3fca2129d7186979ae47c06be33903243",
+      "sha256": null
+    },
+    {
+      "name": "video_preprocessor_config.json",
+      "size": 385,
+      "blob_id": "3ba673a5ad7d4d13f54155ecd38b2a94a6dac8fe",
+      "sha256": null
+    },
+    {
+      "name": "vocab.json",
+      "size": 6722759,
+      "blob_id": "0aa0ce0658d60ac4a5d609f4eadb0e8e43514176",
+      "sha256": null
+    }
+  ]
+}

mlx/src/solomon_mlx_hub/data/release.json

@@ -0,0 +1,105 @@
+{
+  "base_manifest_sha256": "e62a6942465b43f7f47616e36a16d6f32a1bd9daa5124dd26bf61b8eab0c3b6d",
+  "base_repo_id": "Qwen/Qwen3.8-27B",
+  "binding_contract": {
+    "adapter_dtype": "float32",
+    "adapter_placement": "question",
+    "adapter_scale": 2.0,
+    "base_hashes": {
+      ".gitattributes": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930",
+      "LICENSE": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+      "README.md": "57e4bdb258ee1a7d2635c5174ebd4e56abe392505cdb5f8bbb356b0dc4293641",
+      "chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041",
+      "config.json": "191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab",
+      "crc32.txt": "b42dd291f5f98b05807e458f5b47849969a9b3326acbf0c97d28b05826740b83",
+      "generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+      "merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+      "model-00001-of-00018.safetensors": "ba0ce20aae489ad196733da5064bcdf159a1fe84f53336648196e1ebb7751b1c",
+      "model-00002-of-00018.safetensors": "06a148c01bfbe3faa14a5f184a7ff29a706f7ae1c8b2705d2058e26d17a001fb",
+      "model-00003-of-00018.safetensors": "2e1bf62cbcd406eaa64b60d10353e1f0ef4039d0976e56f05cabe953454f9968",
+      "model-00004-of-00018.safetensors": "511e34063187882659753c4d93f3859f93c019fd438d8813071921c81d9a3f1a",
+      "model-00005-of-00018.safetensors": "635cb53446dc74f219740fc59e18b774f877b803b9722e289ca62575a6efa701",
+      "model-00006-of-00018.safetensors": "0bc5214fac607f0e6cc92eec3789d4b8559410ef9fce66621ba8158e8410dae0",
+      "model-00007-of-00018.safetensors": "80b0c49033e9a0d5762562aa12f4acdb7f54da586f3d0110f28c48d91cf07892",
+      "model-00008-of-00018.safetensors": "7192c5b66185d3592927daabee1cc19e6f6e0ce75988ee20e824b624765fda79",
+      "model-00009-of-00018.safetensors": "af3c48cc37af44f3db6ae0579baf019180d48d9c527caa0a1f03ff85813a56d8",
+      "model-00010-of-00018.safetensors": "163490a76f3bea3a40855b7efc04ce6d27afaf1a34f0bbde495b9491f76457c9",
+      "model-00011-of-00018.safetensors": "5f3ae1b948aeee39da77aec558e8236cd65fe4d7cb7686a76bb007acc563c6d8",
+      "model-00012-of-00018.safetensors": "a3de1c7114677a8f5ac5c4892c90e8238ea5c1e2038c80e757dfc87c3902ca55",
+      "model-00013-of-00018.safetensors": "06ab79a41f74c9c5cb734816feb0c7fc364104b227165ee7391231e1155aa02a",
+      "model-00014-of-00018.safetensors": "4138ed94603065ba884bbcadedb04d7718bb40117e85e6f5c6fc5b9c05b7a85b",
+      "model-00015-of-00018.safetensors": "69224e27b9de4e7dbf6fc936c6eaae08447bda3b80a6c31a871ab451173afd22",
+      "model-00016-of-00018.safetensors": "73cb9a1089fb6155cb648609478d6633be8a5c7d9ca5a05bc8925ce8a553cefe",
+      "model-00017-of-00018.safetensors": "beb51f01056142ac4984bd800507b0dd0fd18de57f8e9ef6ea41d1a3598983a8",
+      "model-00018-of-00018.safetensors": "1d3479509e21494658f9b64d317f5ea8e55c4025d28c702d6c4d0b356ce8ea06",
+      "model.safetensors.index.json": "77042094076611b69791a610065f28b7013b8c621795fa86ddccc8bac7d1b9df",
+      "preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+      "tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+      "tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+      "video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+      "vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003"
+    },
+    "base_revision": "1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0",
+    "conversion": "upstream Qwen3.5 sanitization, norms promoted before unit offset",
+    "dependencies": {
+      "mlx": "0.32.2",
+      "mlx-vlm": "0.7.1",
+      "numpy": "2.5.3",
+      "transformers": "5.17.0"
+    },
+    "dtype": "bfloat16",
+    "head_dtype": "float32",
+    "profile": "quality",
+    "quantization": null,
+    "recurrent_state_dtype": "float32",
+    "schema": "solomon-mlx-binding-v1",
+    "sensitive_parameters": "FP32 normalization weights, A_log and dt_bias",
+    "solomon_revision": "2ec506902269e4636285c8811f6c0f52c9300c0c"
+  },
+  "converter_code_sha256": "bbcae17fc1c35db80a79d5865133a42ef9a1b0cf342fff71949972e69cce43ec",
+  "reference_files": {
+    "LICENSE": "a61385b8bc4e786195136404b4975fede3c0bca526877f526482e9af93d47457",
+    "MODIFICATIONS.md": "218218b43b27132a6cfa032d2be908decd0966f5b655946a8668506731c77de7",
+    "NOTICE": "ccf2b8e98f0606945a5fcf9f6522c1f2c01b279d55dc21ee02c5a4acadf8e8d1",
+    "adapter.safetensors": "2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca",
+    "backbone/.gitattributes": "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930",
+    "backbone/LICENSE": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+    "backbone/README.md": "57e4bdb258ee1a7d2635c5174ebd4e56abe392505cdb5f8bbb356b0dc4293641",
+    "backbone/chat_template.jinja": "c3cf9e34abf4f9e36c2d72165aa9c132d3e2a725b6c2586aaa3a8af9d7a81041",
+    "backbone/config.json": "191e0af232104ed8b65258cf3fb2b842e288008baca7633c11b82a1ac7203aab",
+    "backbone/crc32.txt": "b42dd291f5f98b05807e458f5b47849969a9b3326acbf0c97d28b05826740b83",
+    "backbone/generation_config.json": "e70c136c1b78ddc1fb0905bac8e733a4dc448d4f852a5dd75143fffc70be550e",
+    "backbone/merges.txt": "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d",
+    "backbone/model-00001-of-00018.safetensors": "6c54d794f08d8a479e8a123b6ab3473b8a8f304f0da59b043aabe7bdb5f05a7a",
+    "backbone/model-00002-of-00018.safetensors": "3de19e7456388362e7dbe1455362f6b2661d8d7084a7a346e7d3f77053ff0f78",
+    "backbone/model-00003-of-00018.safetensors": "103e7f75798c312e696d2547889732b110a634725f6233b7b0bc654bf3365528",
+    "backbone/model-00004-of-00018.safetensors": "9b6ff88af2b387c943366b263d1ebef06090cf2a94e637895a74eb10300bf5da",
+    "backbone/model-00005-of-00018.safetensors": "f2e95aa5371257fadde49c6d735b716aab00868ae689befd54c091df7a6c57b4",
+    "backbone/model-00006-of-00018.safetensors": "7c196564fbb98f683573ae02d3a90bd74ccb7289d9103f09c76d9feffcc64b24",
+    "backbone/model-00007-of-00018.safetensors": "1a657de97643d5283547047925453e0bbec151b5f293f0a48ee8fbffb82c83cb",
+    "backbone/model-00008-of-00018.safetensors": "e26030a4ee68739f4092696d685b9ef5b4a7052f4843e949cf4419ee7d086b81",
+    "backbone/model-00009-of-00018.safetensors": "d73885d7e8995d58cd722b6fd4976035f30e3464189a71d88bb8e504a4612c53",
+    "backbone/model-00010-of-00018.safetensors": "ee367c91f6faf3a2d5245e28ee20dbe4e51a1ab08f8e27029c67e7c47a77bd89",
+    "backbone/model-00011-of-00018.safetensors": "01ea6406c8ee3f3bd0cbe96fb1ff120bdafc20bdeb4eb5dc8fc08894fef9221f",
+    "backbone/model-00012-of-00018.safetensors": "59da9b95e4d818c1189f681044df6bb9a5c7375ea0a01b8d6a6a682451fc4a8e",
+    "backbone/model-00013-of-00018.safetensors": "c2f63ec1a168d0f328da8ef74caee72d4e67d6dccfd9ccb595abcaedaeae86c4",
+    "backbone/model-00014-of-00018.safetensors": "d8a6453ec4fbe9763644dd9127c3a5ad5fec5c8a5cde6f1414f1101ee9a1250c",
+    "backbone/model-00015-of-00018.safetensors": "95db368ab83b8f60d1b9205de6ffa97adbe665d7e61e9adcfb237d25dabf9f8a",
+    "backbone/model-00016-of-00018.safetensors": "482d3d948c8cb31068323a85b7c2d445271a28a08699bbed48c13e465894715a",
+    "backbone/model-00017-of-00018.safetensors": "7615db84bee928608723f0e5e887f98e11091ccd86583453efcf9745050741f2",
+    "backbone/model-00018-of-00018.safetensors": "1219c9ea7951f2bb93c0ccafa2e6e65ac9111fda00961e3fbe614e30050c95e9",
+    "backbone/model.safetensors.index.json": "5aec933c5ef08d6c1d411b1b1f225b97d7c55f8eeed4b74535849ce9361e595f",
+    "backbone/preprocessor_config.json": "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516",
+    "backbone/tokenizer.json": "0997f410c57a1f4e53b09e4be8f4a172d90edd9564368fb0847030937229b9f3",
+    "backbone/tokenizer_config.json": "b11349aafa7cdc6a320767cf7ceb29ed82f7eda5d65e8e0819e76f0ce947bf27",
+    "backbone/video_preprocessor_config.json": "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13",
+    "backbone/vocab.json": "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003",
+    "heads.npz": "126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f"
+  },
+  "repo_id": "DoccyHealth/Solomon",
+  "schema": "solomon-mlx-hub-release-v1",
+  "source_hashes": {
+    "adapter/adapter.safetensors": "2addaf841ecc58829ad73081603b8d3e52743c53c6d558a17a1dd30e9bd2dbca",
+    "adapter/heads.npz": "126a9b5487dca937a768a4f228f2d2e7d513900d8ad0e99c4137fbaa42a1aa6f"
+  }
+}

mlx/src/solomon_mlx_hub/prepare.py

@@ -0,0 +1,212 @@
+"""Verified, atomic local assembly without redistributing the Qwen backbone.
+
+This separate package leaves the historical converter and running inference code
+unchanged. Conversion uses the original FP32 normalization-offset treatment.
+"""
+
+import copy
+import fcntl
+import json
+import re
+import shutil
+import tempfile
+from contextlib import contextmanager
+from importlib.metadata import version
+from pathlib import Path, PurePosixPath
+
+from huggingface_hub import snapshot_download
+
+from solomon_mlx.artifacts import code_identity, sha256
+from solomon_mlx.prepare import convert_bf16, verify_base
+
+DATA = Path(__file__).parent / "data"
+RELEASE = json.loads((DATA / "release.json").read_text())
+MANIFEST = DATA / "base-manifest.json"
+SOURCE_PATTERNS = [
+    "adapter/**",
+    "mlx/bf16/LICENSE",
+    "mlx/bf16/NOTICE",
+    "mlx/bf16/MODIFICATIONS.md",
+]
+
+
+def _revision(revision):
+    if not isinstance(revision, str) or not re.fullmatch(r"[0-9a-f]{40}", revision):
+        raise ValueError("Pin the Solomon repository to a full 40-character commit SHA")
+    return revision
+
+
+def _relative(name):
+    path = PurePosixPath(name)
+    if not name or path.is_absolute() or ".." in path.parts or "\\" in name:
+        raise ValueError("Unsafe artifact path: " + name)
+    return path
+
+
+def _check_converter():
+    if code_identity() != RELEASE["converter_code_sha256"]:
+        raise ValueError("Converter source identity mismatch; install the pinned source distribution")
+    for package, expected in RELEASE["binding_contract"]["dependencies"].items():
+        if version(package) != expected:
+            raise ValueError(f"Converter requires {package}=={expected}")
+    if sha256(MANIFEST) != RELEASE["base_manifest_sha256"]:
+        raise ValueError("Pinned base manifest checksum mismatch")
+
+
+def verify_prepared(directory):
+    """Verify an existing local conversion without allocating model tensors.
+
+    Historical conversions remain usable. Their bindings and byte checksums are
+    preserved; a new conversion always receives its own output checksums.
+    """
+    root = Path(directory).resolve()
+    binding = json.loads((root / "binding.json").read_text())
+    for key, expected in RELEASE["binding_contract"].items():
+        if binding.get(key) != expected:
+            raise ValueError("Local binding mismatch: " + key)
+    for key, expected in RELEASE["source_hashes"].items():
+        if binding.get("source_hashes", {}).get(key) != expected:
+            raise ValueError("Local source identity mismatch: " + key)
+    files = binding.get("files", {})
+    if set(files) != set(RELEASE["reference_files"]):
+        raise ValueError("Local conversion has missing or unexpected bound artifacts")
+    for name, expected in files.items():
+        path = root / _relative(name)
+        if not path.resolve().is_relative_to(root) or sha256(path) != expected:
+            raise ValueError("Local artifact checksum mismatch: " + name)
+        # Safetensors serialization can differ between CPU and Metal. Metadata,
+        # processor files, trained adapter and heads must remain byte-identical.
+        if (
+            not (name.startswith("backbone/") and name.endswith(".safetensors"))
+            and expected != RELEASE["reference_files"][name]
+        ):
+            raise ValueError("Pinned artifact identity mismatch: " + name)
+    return binding
+
+
+@contextmanager
+def _output_lock(output):
+    output.parent.mkdir(parents=True, exist_ok=True)
+    # Keep the lock inode after release so concurrent waiters cannot bypass it.
+    with (output.parent / f".{output.name}.prepare.lock").open("a") as handle:
+        try:
+            fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError as exc:
+            raise RuntimeError("Another process is preparing this output") from exc
+        try:
+            yield
+        finally:
+            fcntl.flock(handle, fcntl.LOCK_UN)
+
+
+def _assemble(snapshot, output, *, revision, base_dir, device):
+    source = Path(snapshot)
+    for name, expected in RELEASE["source_hashes"].items():
+        if sha256(source / _relative(name)) != expected:
+            raise ValueError("Solomon source checksum mismatch: " + name)
+    for name in ("LICENSE", "NOTICE", "MODIFICATIONS.md"):
+        if sha256(source / "mlx/bf16" / name) != RELEASE["reference_files"][name]:
+            raise ValueError("Solomon license/provenance checksum mismatch: " + name)
+
+    manifest = json.loads(MANIFEST.read_text())
+    if base_dir is None:
+        base_dir = output.parent / ".solomon-sources" / ("base-" + manifest["revision"])
+        snapshot_download(
+            RELEASE["base_repo_id"],
+            revision=manifest["revision"],
+            local_dir=base_dir,
+            allow_patterns=[row["name"] for row in manifest["files"]],
+            max_workers=8,
+        )
+    base_dir = Path(base_dir)
+    base_hashes = verify_base(base_dir, manifest)
+    if base_hashes != RELEASE["binding_contract"]["base_hashes"]:
+        raise ValueError("Base input identity differs from the original conversion")
+
+    temporary = Path(tempfile.mkdtemp(prefix=f".{output.name}.", dir=output.parent))
+    try:
+        import mlx.core as mx
+
+        # Device selection is scoped to this conversion; CPU conversion also
+        # works on Linux. Inference still requires Apple Silicon and Metal.
+        with mx.stream(mx.cpu if device == "cpu" else mx.gpu):
+            convert_bf16(base_dir, temporary / "backbone")
+        for name in RELEASE["source_hashes"]:
+            shutil.copy2(source / name, temporary / Path(name).name)
+        for name in ("LICENSE", "NOTICE", "MODIFICATIONS.md"):
+            shutil.copy2(source / "mlx/bf16" / name, temporary / name)
+        binding = copy.deepcopy(RELEASE["binding_contract"])
+        binding["source_hashes"] = RELEASE["source_hashes"]
+        binding["files"] = {
+            str(p.relative_to(temporary)): sha256(p) for p in sorted(temporary.rglob("*")) if p.is_file()
+        }
+        binding["hub_preparation"] = {
+            "repo_id": RELEASE["repo_id"],
+            "revision": revision,
+            "converter_code_sha256": RELEASE["converter_code_sha256"],
+            "loader_code_sha256": sha256(__file__),
+            "device": device,
+            "base_manifest_sha256": RELEASE["base_manifest_sha256"],
+            "calibration": "none; CUDA parity only",
+        }
+        (temporary / "binding.json").write_text(json.dumps(binding, indent=2, sort_keys=True) + "\n")
+        verify_prepared(temporary)
+        temporary.rename(output)
+    finally:
+        if temporary.exists():
+            shutil.rmtree(temporary)
+    return output
+
+
+def prepare_from_snapshot(snapshot, output, *, revision, base_dir, device="cpu"):
+    """Offline preparation from an adapter-only snapshot and original Qwen files."""
+    _revision(revision)
+    if base_dir is None:
+        raise ValueError("Offline preparation requires the original Qwen base directory")
+    if device not in ("cpu", "gpu"):
+        raise ValueError("Conversion device must be cpu or gpu")
+    _check_converter()
+    output = Path(output).absolute()
+    with _output_lock(output):
+        if output.exists():
+            verify_prepared(output)
+            return output
+        return _assemble(Path(snapshot), output, revision=revision, base_dir=base_dir, device=device)
+
+
+def prepare_from_hub(output, *, revision, base_dir=None, cache_dir=None, device="cpu"):
+    """Download root adapters and pinned base inputs; return a verified local model.
+
+    Existing valid outputs are reused without network traffic or rewriting their
+    runtime identity. Invalid outputs fail closed and are never overwritten.
+    """
+    _revision(revision)
+    if device not in ("cpu", "gpu"):
+        raise ValueError("Conversion device must be cpu or gpu")
+    _check_converter()
+    output = Path(output).absolute()
+    with _output_lock(output):
+        if output.exists():
+            verify_prepared(output)
+            return output
+        snapshot = snapshot_download(
+            RELEASE["repo_id"],
+            revision=revision,
+            allow_patterns=SOURCE_PATTERNS,
+            cache_dir=cache_dir,
+        )
+        return _assemble(Path(snapshot), output, revision=revision, base_dir=base_dir, device=device)
+
+
+def load(output, *, revision, base_dir=None, cache_dir=None, device="cpu", **model_options):
+    """Prepare the adapter-only release, then load the standard Solomon API."""
+    from solomon_mlx import Solomon
+
+    directory = prepare_from_hub(
+        output,
+        revision=revision,
+        base_dir=base_dir,
+        cache_dir=cache_dir,
+        device=device,
+    )
+    return Solomon.load(directory, **model_options)

mlx/tests/test_artifacts_and_evaluation.py

@@ -0,0 +1,77 @@
+import hashlib
+import json
+
+import numpy as np
+import pytest
+
+from solomon_mlx.artifacts import BASE_REVISION, verify_release
+from solomon_mlx.evaluation import compare_rows, unit
+from solomon_mlx.prepare import verify_base
+
+
+def test_corrupt_source_and_base_fail_closed(tmp_path):
+    path = tmp_path / "input"
+    path.write_bytes(b"original")
+    sha = hashlib.sha256(b"original").hexdigest()
+    (tmp_path / "MANIFEST.json").write_text(
+        json.dumps({"files": [{"destination": "input", "staged_bytes": 8, "staged_sha256": sha}]})
+    )
+    assert verify_release(tmp_path)["input"] == sha
+    manifest = {"revision": BASE_REVISION, "files": [{"name": "input", "size": 8, "sha256": sha}]}
+    assert verify_base(tmp_path, manifest)["input"] == sha
+    path.write_bytes(b"corrupt!")
+    with pytest.raises(ValueError):
+        verify_release(tmp_path)
+    with pytest.raises(ValueError):
+        verify_base(tmp_path, manifest)
+
+
+def test_reserved_choice_exclusion_and_whole_question_accuracy():
+    rows = [
+        {
+            "id": "a",
+            "task": "entity",
+            "n": 4,
+            "head_key": "entity/state4",
+            "question_id": "q",
+            "gold": 0,
+            "letter_logits": [5, 0, 0, 0],
+        },
+        {
+            "id": "b",
+            "task": "entity",
+            "n": 4,
+            "head_key": "entity/state4",
+            "question_id": "q",
+            "gold": 3,
+            "letter_logits": [0, 0, 0, 5],
+        },
+    ]
+    other = [{**rows[0]}, {**rows[1], "letter_logits": [5, 0, 0, 0]}]
+    report = compare_rows(rows, other)
+    assert report["unit_decision_agreement"] == 0.5
+    assert report["mlx_whole_question_accuracy"] == 1
+    assert report["cuda_whole_question_accuracy"] == 0
+    assert not report["quality_gate_passed"]
+    assert unit(
+        {"task": "single", "n": 4, "head_key": "single/choiceR", "gold": 3, "letter_logits": [1, 2, 3, 4]}
+    ) == (None, None)
+
+
+def test_norm_offset_preserves_bf16_source_values_in_fp32():
+    from types import SimpleNamespace
+
+    import mlx.core as mx
+    from mlx_vlm.models.qwen3_5.qwen3_5 import Model
+
+    # Sanitization requires config only for tied embeddings and image channels.
+    config = SimpleNamespace(
+        text_config=SimpleNamespace(tie_word_embeddings=False), vision_config=SimpleNamespace(in_channels=3)
+    )
+    original = mx.array([0.02, -0.04], dtype=mx.bfloat16)
+    converted = Model.sanitize(
+        SimpleNamespace(config=config), {"model.language_model.norm.weight": original.astype(mx.float32)}
+    )
+    out = converted["language_model.model.norm.weight"]
+    assert out.dtype == mx.float32
+    np.testing.assert_array_equal(np.asarray(out), np.asarray(original.astype(mx.float32)) + 1)

mlx/tests/test_budget.py

@@ -0,0 +1,24 @@
+import json
+
+import pytest
+
+from solomon_mlx.budget import Budget
+
+
+def test_budget_reserves_before_dispatch_and_exhausts(tmp_path):
+    path = tmp_path / "budget.json"
+    budget = Budget(path, 20)
+    with budget.reserve(15, "one"):
+        assert json.loads(path.read_text())["entries"][0]["status"] == "reserved"
+        with pytest.raises(RuntimeError), budget.reserve(1, "concurrent"):
+            pass
+    with pytest.raises(RuntimeError), budget.reserve(6, "too expensive"):
+        pass
+
+
+def test_uncertain_dispatch_blocks_followups(tmp_path):
+    budget = Budget(tmp_path / "budget.json")
+    with pytest.raises(TimeoutError), budget.reserve(20, "uncertain"):
+        raise TimeoutError()
+    with pytest.raises(RuntimeError), budget.reserve(20, "retry"):
+        pass

mlx/tests/test_contract.py

@@ -0,0 +1,96 @@
+import math
+import threading
+
+import pytest
+
+from solomon_mlx._vendor.contract import parse_questions
+from solomon_mlx._vendor.semantics import p_yes
+from solomon_mlx.api import Solomon, branches, distributions, ordering_score
+
+
+def test_collapse_before_temperature():
+    p = p_yes([0, 0, 0, 0], 2)
+    assert p == pytest.approx(1 / (1 + math.sqrt(3)))
+    assert p != pytest.approx(0.25)
+
+
+def test_routing_and_candidate_order():
+    specs = parse_questions(
+        {
+            "single": {"type": "choice", "instructions": "Who?", "options": ["A", "B"]},
+            "ordered": {"type": "score", "instructions": "Level?", "levels": ["low", "high"]},
+            "entity": {"instructions": "Is {candidate} certified?", "candidates": ["Z", "X"]},
+        }
+    )
+    assert branches(specs[0])[0][1:] == (4, "single/choiceR")
+    assert branches(specs[1])[0][1:] == (2, "ordered/choiceS")
+    assert "Is Z certified?" in branches(specs[2])[0][0]
+    assert distributions(specs[0], [{"letter_logits": [0, 0, 100, 100]}], 1) == [[0.5, 0.5]]
+
+
+def test_ordering_score_product():
+    assert ordering_score([[0.8, 0.2], [0.1, 0.9]]) == pytest.approx(0.72)
+    with pytest.raises(ValueError):
+        ordering_score([[0.8, 0.3]])
+
+
+class FakeEngine:
+    def __init__(self):
+        self.identity = {"fingerprint": "test-only"}
+        self.lock = threading.RLock()
+        self.prefills = []
+
+    def prefill(self, parts):
+        self.prefills.append(parts)
+        return {"parts": parts, "prefix_ids": [1, 2]}
+
+    def ask(self, state, block, width, head, **kwargs):
+        return {
+            "letter_logits": [2.0] + [0.0] * (width - 1),
+            "branch_tokens": 3,
+            "prompt_tokens": 5,
+            "head_key": head,
+        }
+
+
+def test_state_ownership_close_and_replay(tmp_path):
+    model = Solomon(FakeEngine())
+    other = Solomon(FakeEngine())
+    state = model.prefill("A fact.")
+    recipe = tmp_path / "state.json"
+    state.save(recipe)
+    with pytest.raises(ValueError):
+        other.decide(state=state, questions={"a": "Fact?"})
+    state.close()
+    with pytest.raises(ValueError):
+        model.decide(state=state, questions={"a": "Fact?"})
+    with model.replay(recipe) as restored:
+        assert restored.prefix_tokens == 2
+    recipe.write_text(recipe.read_text().replace("A fact.", "Bad fact."))
+    with pytest.raises(ValueError):
+        model.replay(recipe)
+
+
+def test_evidence_budget_stops_fresh_calls():
+    engine = FakeEngine()
+    model = Solomon(engine)
+    with model.prefill("Alice is certified.\nBob is not certified.") as state:
+        result = model.decide(
+            state=state, questions={"a": "Is Alice certified?"}, evidence="removal", evidence_max_calls=0
+        )
+    assert result["answers"]["a"]["evidence_status"] == "budget_exhausted"
+    assert len(engine.prefills) == 1
+
+
+def test_evidence_spans_and_fresh_verification():
+    engine = FakeEngine()
+    model = Solomon(engine)
+    text = "Alice is certified.\nBob is not certified."
+    with model.prefill(text) as state:
+        out = model.decide(state=state, questions={"a": "Is Alice certified?"}, evidence="removal")[
+            "answers"
+        ]["a"]
+    assert len(engine.prefills) == 3
+    for span in out["evidence"]:
+        assert text[span["start"] : span["end"]] == span["text"]
+    assert out["evidence_detail"]["verification"] == "fresh_source_reencoding"

mlx/tests/test_hub.py

@@ -0,0 +1,173 @@
+"""Adapter-only downloads, immutable reuse, integrity failures and atomic assembly."""
+
+import copy
+import fcntl
+import json
+from pathlib import Path
+
+import pytest
+
+import solomon_mlx_hub.prepare as hub
+from solomon_mlx.artifacts import sha256
+
+REVISION = "a" * 40
+
+
+@pytest.fixture
+def release(tmp_path, monkeypatch):
+    source, base = tmp_path / "source", tmp_path / "base"
+    (source / "adapter").mkdir(parents=True)
+    (source / "mlx/bf16").mkdir(parents=True)
+    base.mkdir()
+    payloads = {"adapter.safetensors": b"trained adapter", "heads.npz": b"trained heads"}
+    for name, value in payloads.items():
+        (source / "adapter" / name).write_bytes(value)
+    for name in ("LICENSE", "NOTICE", "MODIFICATIONS.md"):
+        (source / "mlx/bf16" / name).write_text(name)
+    (base / "config.json").write_text('{"model_type":"qwen3_5"}')
+    manifest = tmp_path / "base-manifest.json"
+    manifest.write_text(
+        json.dumps(
+            {
+                "revision": hub.RELEASE["binding_contract"]["base_revision"],
+                "files": [
+                    {
+                        "name": "config.json",
+                        "size": (base / "config.json").stat().st_size,
+                        "sha256": sha256(base / "config.json"),
+                    }
+                ],
+            }
+        )
+    )
+    reference = {
+        **{name: sha256(source / "adapter" / name) for name in payloads},
+        **{name: sha256(source / "mlx/bf16" / name) for name in ("LICENSE", "NOTICE", "MODIFICATIONS.md")},
+        "backbone/config.json": sha256(base / "config.json"),
+        "backbone/model.safetensors": "historical-serialization-hash",
+    }
+    spec = copy.deepcopy(hub.RELEASE)
+    spec["reference_files"] = reference
+    spec["base_manifest_sha256"] = sha256(manifest)
+    spec["source_hashes"] = {"adapter/" + name: reference[name] for name in payloads}
+    spec["binding_contract"]["base_hashes"] = {"config.json": sha256(base / "config.json")}
+    monkeypatch.setattr(hub, "RELEASE", spec)
+    monkeypatch.setattr(hub, "MANIFEST", manifest)
+    calls = []
+
+    def convert(root, output):
+        assert Path(root) == base
+        calls.append("convert")
+        output.mkdir()
+        (output / "config.json").write_bytes((base / "config.json").read_bytes())
+        (output / "model.safetensors").write_bytes(b"new serialization")
+
+    monkeypatch.setattr(hub, "convert_bf16", convert)
+    return source, base, tmp_path / "model", calls
+
+
+def test_adapter_only_hub_then_verified_offline_reuse(release, monkeypatch):
+    source, base, output, calls = release
+
+    def download(repo_id, **kwargs):
+        assert repo_id == "DoccyHealth/Solomon"
+        assert kwargs["revision"] == REVISION
+        assert "adapter/**" in kwargs["allow_patterns"]
+        assert not any(
+            "backbone" in pattern or pattern == "mlx/bf16/**" for pattern in kwargs["allow_patterns"]
+        )
+        calls.append("download")
+        return str(source)
+
+    monkeypatch.setattr(hub, "snapshot_download", download)
+    assert hub.prepare_from_hub(output, revision=REVISION, base_dir=base) == output
+    binding = hub.verify_prepared(output)
+    assert binding["hub_preparation"]["revision"] == REVISION
+    assert binding["adapter_scale"] == 2.0
+    assert binding["files"]["backbone/model.safetensors"] != "historical-serialization-hash"
+    original_binding = (output / "binding.json").read_bytes()
+    assert hub.prepare_from_hub(output, revision=REVISION) == output
+    assert calls == ["download", "convert"]
+    assert (output / "binding.json").read_bytes() == original_binding
+    (output / "adapter.safetensors").write_bytes(b"corrupt")
+    with pytest.raises(ValueError, match="checksum mismatch"):
+        hub.prepare_from_hub(output, revision=REVISION)
+    assert calls == ["download", "convert"]
+
+
+def test_base_download_pinned_and_verified_before_conversion(release, monkeypatch):
+    source, _base, output, calls = release
+
+    def download(repo_id, **kwargs):
+        calls.append(repo_id)
+        if repo_id == "DoccyHealth/Solomon":
+            return source
+        assert repo_id == "Qwen/Qwen3.8-27B"
+        assert kwargs["revision"] == hub.RELEASE["binding_contract"]["base_revision"]
+        target = Path(kwargs["local_dir"])
+        target.mkdir(parents=True)
+        (target / "config.json").write_bytes(b"corrupt base")
+
+    monkeypatch.setattr(hub, "snapshot_download", download)
+    with pytest.raises(ValueError, match="Base size mismatch"):
+        hub.prepare_from_hub(output, revision=REVISION)
+    assert calls == ["DoccyHealth/Solomon", "Qwen/Qwen3.8-27B"]
+    assert not output.exists()
+
+
+def test_bad_source_stops_before_base_or_conversion(release):
+    source, base, output, calls = release
+    (source / "adapter/heads.npz").write_bytes(b"corrupt")
+    with pytest.raises(ValueError, match="source checksum mismatch"):
+        hub.prepare_from_snapshot(source, output, revision=REVISION, base_dir=base)
+    assert not calls and not output.exists()
+
+
+def test_converter_failure_is_atomic_and_retryable(release, monkeypatch):
+    source, base, output, calls = release
+    convert = hub.convert_bf16
+
+    def fail(*args):
+        args[1].mkdir()
+        (args[1] / "partial").write_bytes(b"partial output")
+        raise RuntimeError("conversion failed")
+
+    monkeypatch.setattr(hub, "convert_bf16", fail)
+    with pytest.raises(RuntimeError, match="conversion failed"):
+        hub.prepare_from_snapshot(source, output, revision=REVISION, base_dir=base)
+    assert not output.exists()
+    assert list(output.parent.glob(".model.*")) == [output.parent / ".model.prepare.lock"]
+    monkeypatch.setattr(hub, "convert_bf16", convert)
+    hub.prepare_from_snapshot(source, output, revision=REVISION, base_dir=base)
+    assert calls == ["convert"]
+
+
+def test_mutable_revision_and_converter_drift_fail_closed(release, monkeypatch):
+    source, base, output, calls = release
+    for revision in (None, "main", "abc123", "A" * 40):
+        with pytest.raises(ValueError, match="commit SHA"):
+            hub.prepare_from_hub(output, revision=revision)
+    monkeypatch.setattr(hub, "code_identity", lambda: "changed source")
+    with pytest.raises(ValueError, match="Converter source identity"):
+        hub.prepare_from_snapshot(source, output, revision=REVISION, base_dir=base)
+    assert not calls
+
+
+def test_bound_paths_cannot_escape_output(release):
+    source, base, output, _calls = release
+    hub.prepare_from_snapshot(source, output, revision=REVISION, base_dir=base)
+    external = output.parent / "external"
+    target = output / "backbone/model.safetensors"
+    target.rename(external)
+    target.symlink_to(external)
+    with pytest.raises(ValueError, match="checksum mismatch"):
+        hub.verify_prepared(output)
+
+
+def test_simultaneous_preparations_fail_without_mutation(release):
+    source, base, output, calls = release
+    with (output.parent / ".model.prepare.lock").open("a") as handle:
+        fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        with pytest.raises(RuntimeError, match="Another process"):
+            hub.prepare_from_snapshot(source, output, revision=REVISION, base_dir=base)
+    assert not output.exists() and not calls

mlx/tests/test_metal_primitives.py

@@ -0,0 +1,40 @@
+import mlx.core as mx
+import numpy as np
+from mlx import nn
+from mlx_vlm.models.cache import ArraysCache, KVCache
+
+from solomon_mlx.engine import SwitchLoRA, fork_cache
+
+
+def test_question_cache_isolation():
+    kv = KVCache()
+    kv.update_and_fetch(mx.ones((1, 2, 7, 4)), mx.ones((1, 2, 7, 4)))
+    recurrent = ArraysCache(2)
+    recurrent.cache = [mx.ones((1, 3, 4)), mx.ones((1, 2, 4, 4), dtype=mx.float32)]
+    mx.eval(kv.state, recurrent.state)
+    branch = fork_cache([kv, recurrent])
+    branch[0].update_and_fetch(mx.full((1, 2, 2, 4), 9), mx.full((1, 2, 2, 4), 8))
+    branch[1].cache[0][:] = 12
+    branch[1].cache[1][:] = 15
+    mx.eval(branch[0].state, branch[1].state)
+    assert kv.offset == 7
+    np.testing.assert_array_equal(np.asarray(kv.keys[:, :, :7]), 1)
+    for array in recurrent.cache:
+        np.testing.assert_array_equal(np.asarray(array), 1)
+    # A second independent question starts at the original prefix.
+    assert fork_cache([kv, recurrent])[0].offset == 7
+
+
+def test_lora_boundary_multiplier_and_instance_isolation():
+    context = {"start": None}
+    base = nn.Linear(2, 3, bias=False)
+    base.weight = mx.zeros((3, 2), dtype=mx.bfloat16)
+    layer = SwitchLoRA(base, mx.ones((2, 1)), mx.ones((1, 3)), context)
+    x = mx.ones((1, 4, 2), dtype=mx.bfloat16)
+    np.testing.assert_array_equal(np.asarray(layer(x).astype(mx.float32)), 0)
+    context["start"] = 2
+    out = np.asarray(layer(x).astype(mx.float32))
+    np.testing.assert_array_equal(out[:, :2], 0)
+    np.testing.assert_array_equal(out[:, 2:], 4)
+    other = SwitchLoRA(base, mx.ones((2, 1)), mx.ones((1, 3)), {"start": None})
+    np.testing.assert_array_equal(np.asarray(other(x).astype(mx.float32)), 0)

mlx/tests/test_parity.py

@@ -0,0 +1,24 @@
+"""Keep the user-selected parity workflow free of calibration jobs."""
+
+import importlib.util
+from pathlib import Path
+
+
+def test_parity_keeps_branches_whose_gold_label_is_reserved():
+    script = Path(__file__).resolve().parents[1] / "scripts/check_cuda_parity.py"
+    spec = importlib.util.spec_from_file_location("parity_checker", script)
+    checker = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(checker)
+    row = {
+        "task": "single",
+        "n": 4,
+        "head_key": "single/choiceR",
+        "gold": 3,
+        "letter_logits": [2, 0, 100, 100],
+    }
+    probabilities = checker.decision_probabilities(row, 1.0)
+    assert len(probabilities) == 2
+    assert probabilities.argmax() == 0
+    assert probabilities[0] > 0.88
+
+