Release Jev-Style-0.8B-Decision-v3

.gitattributes

@@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Jev-Style-0.8B-Decision-v3-F16.gguf filter=lfs diff=lfs merge=lfs -text
+Jev-Style-0.8B-Decision-v3-Q4_K_M.gguf filter=lfs diff=lfs merge=lfs -text
+Jev-Style-0.8B-Decision-v3-Q8_0.gguf filter=lfs diff=lfs merge=lfs -text
+figures/latency.png filter=lfs diff=lfs merge=lfs -text
+figures/quantization.png filter=lfs diff=lfs merge=lfs -text
+tokenizer/tokenizer.json filter=lfs diff=lfs merge=lfs -text

Jev-Style-0.8B-Decision-v3-F16.gguf

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

Jev-Style-0.8B-Decision-v3-Q4_K_M.gguf

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

Jev-Style-0.8B-Decision-v3-Q8_0.gguf

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

LICENSE

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

NOTICE

@@ -0,0 +1,35 @@
+chaoliangUNSW/Jev-Style-0.8B-Decision-v3-GGUF
+Copyright 2026 chaoliangUNSW. Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+This model is a fine-tuned derivative of Qwen3.5-0.8B (https://huggingface.co/Qwen/Qwen3.5-0.8B,
+revision 2fc06364715b967f1860aea9cf38778875588b17), Copyright 2026 Alibaba Cloud, licensed under the Apache
+License, Version 2.0. The LICENSE file in this repository is the license file distributed with Qwen3.5-0.8B.
+
+Modifications relative to Qwen3.5-0.8B:
+- all text-model weights were fine-tuned (full fine-tuning, bf16 training) to score typed decision questions
+  (choice / score / true-false) with a verdict readout: logit(" yes") - logit(" no") at one " ->" slot per
+  option; calibration temperatures were fitted afterwards (readout_config.json);
+- the vision tower (model.visual.*) and the multi-token-prediction head (mtp.*) were removed; the checkpoint
+  is a text-only Qwen3_5ForCausalLM with tied input/output embeddings;
+- converted to GGUF (F16) and quantised (Q8_0, Q4_K_M) with the unmodified llama.cpp tools
+  (https://github.com/ggml-org/llama.cpp, MIT License, Copyright The ggml authors), commit 441df11f65ea0b6d0c72965aaf70c8241070ddcb;
+- the GGUF metadata field general.name was set to "Jev-Style-0.8B-Decision-v3" with gguf-py (llama.cpp,
+  gguf_new_metadata.py); tensor data unchanged;
+- added the runtime script, readout/release configuration files, the integrity manifest and this NOTICE.
+
+jev_score.cpp is original code of this project released under Apache-2.0. It is compiled against
+libllama and uses nlohmann/json (MIT) from llama.cpp's vendor directory at build time; neither
+library is redistributed in this repository.
+
+The question types (choice / score / noul) follow the typed-decision convention of Laya
+(https://github.com/NandhaKishorM/laya, Apache-2.0) so both models can be evaluated on the same
+inputs. No Laya code or weights are included.
+
+Third generation (v3) of the Jev-Style decision series. Earlier generations: v1 =
+chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision (public GGUF release: chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-GGUF) and
+v2 = chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2, both 2B models built on Qwen3.5-2B-Base. v3 is fine-tuned from
+Qwen3.5-0.8B; no weights of v1 or v2 were reused.
+
+Not affiliated with, endorsed by or connected to TypeSafe or Jev. "Jev-Style" only describes the kind
+of model (a small typed-decision model in a similar style); no Jev weights, code or outputs are included.
+Not affiliated with or endorsed by Alibaba Cloud / the Qwen team or the Laya authors.

README.md

@@ -0,0 +1,138 @@
+---
+license: apache-2.0
+base_model: chaoliangUNSW/Jev-Style-0.8B-Decision-v3
+base_model_relation: quantized
+library_name: gguf
+pipeline_tag: text-classification
+language:
+  - en
+  - zh
+  - ar
+  - bg
+  - de
+  - el
+  - es
+  - fr
+  - hi
+  - ja
+  - ko
+  - pt
+  - ru
+  - sw
+  - ta
+  - th
+  - tr
+  - ur
+  - vi
+tags:
+  - decision-model
+  - jev-style
+  - system-one
+  - calibration
+  - long-context
+  - multilingual
+  - qwen3.5
+  - gguf
+  - llama.cpp
+---
+
+# Jev-Style-0.8B-Decision-v3-GGUF
+
+**Jev-Style decision series:** [v1 · 2B](https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-GGUF) → [v2 · 2B](https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2-GGUF) → **v3 · 0.8B** · **Website:** [jevstyle.com](https://jevstyle.com)
+
+These are the GGUF builds of [Jev-Style-0.8B-Decision-v3](https://huggingface.co/chaoliangUNSW/Jev-Style-0.8B-Decision-v3).
+**One state. One pass. Every option scored.** The model takes up to 25,600 tokens of input, reads the state once and returns a calibrated
+probability for every option of every question, with no letter cap. **Full results, protocols, training data and
+licences are on the [main model card](https://huggingface.co/chaoliangUNSW/Jev-Style-0.8B-Decision-v3).**
+
+## Files
+
+| File | Quantization | Size | Same decision as PyTorch FP32 (240 parity rows) | Prompts of about 16K / 25.6K tokens |
+|---|---|---:|---:|---:|
+| `Jev-Style-0.8B-Decision-v3-F16.gguf` | F16 | 1.52 GB | **240 / 240** | **6 / 6** |
+| `Jev-Style-0.8B-Decision-v3-Q8_0.gguf` | Q8_0 | 0.81 GB | **240 / 240** | **6 / 6** |
+| `Jev-Style-0.8B-Decision-v3-Q4_K_M.gguf` | Q4_K_M | 0.53 GB | **240 / 240** | **6 / 6** |
+
+<sub>Top-1 agreement with the PyTorch FP32 reference on a 240-row mixed parity fixture (training-pool rows, 22 categories, English and Chinese) plus 6 extra long prompts. These rows test agreement between formats, not accuracy. Sizes are the exported files (GB = 10^9 bytes). F16 is the runtime's default and the backend used for the latency figures.</sub>
+
+## Highlights
+
+- **4-bit, 0.53 GB, same calls.** The Q4_K_M file matches PyTorch FP32 on 240 of 240 parity rows, plus 6 of 6
+  prompts at about 16K and 25.6K tokens, and it is about 2.4× smaller than the 2B v2's Q4_K_M (1.27 GB).
+- **Up to 4.6× faster than a Laya-architecture engine when 10 questions share one 4K-token state** (1,381 ms vs
+  6,364 ms with `many_mode="batched"`; the engine is our round-1 MacLaya-4K, one call per question, not an official
+  Laya checkpoint), because in that mode the bundled scorer reads the state once. It also answers questions about 8K-token states in 2.3 to 2.6 s.
+- **79.2% on 2,000 typed decisions**, +6.4 points over Jev and +5.7 over the 2B v2, with a 3.2× lower Brier score
+  than Jev (in-domain for v3, zero-shot for Jev).
+
+![Quantization: top-1 agreement with full precision and file size](figures/quantization.png)
+
+![Latency: many questions on one long state](figures/latency.png)
+
+<sub>Latency: untrained identical-architecture Qwen3.5-0.8B export on llama.cpp GGUF F16, one call per state with all questions scored together (`many_mode="batched"`); comparison engine = round-1 MacLaya-4K, our own fine-tune of the Laya multilingual architecture (FP32 on Apple MPS, 4,096-token budget, one call per question), not an official Laya checkpoint; Apple M1 Max 64 GB, warm p50, idle run 2026-09-23. v3 parity rows are drawn from the training pool; 2B v1/v2 quantization numbers and sizes are as reported on their public GGUF cards (their own 500 held-out decisions), so no agreement gap is claimed. More protocol detail is on the main card.</sub>
+
+## Quick start
+
+The files are standard Qwen3.5 text models, so any recent llama.cpp loads them. Chat or text generation does
+**not** give you the model's decisions, though. Decisions are read at one verdict slot per option, and the bundled
+scorer does exactly that.
+
+```bash
+pip install -U huggingface_hub
+hf download chaoliangUNSW/Jev-Style-0.8B-Decision-v3-GGUF --local-dir jev-v3-gguf
+cd jev-v3-gguf
+pip install -r requirements.txt                 # tokenizers, numpy
+
+# Build the scorer against llama.cpp (tested at commit 441df11f65ea0b6d0c72965aaf70c8241070ddcb or later).
+git clone https://github.com/ggml-org/llama.cpp
+git -C llama.cpp checkout 441df11f65ea0b6d0c72965aaf70c8241070ddcb
+sh build_jev_score.sh llama.cpp                 # -> ./build/jev-score (Metal on macOS)
+# Linux + CUDA: LLAMA_CMAKE_FLAGS="-DGGML_CUDA=ON" sh build_jev_score.sh llama.cpp
+
+python jev_style_decision_gguf.py --quant Q4_K_M \
+  --state "The film was excellent." \
+  --question "What is the sentiment of this review?" \
+  --options '["negative", "positive"]' --category general_sentiment
+```
+
+From Python, the API is the same as the main repository's runtime:
+
+```python
+from jev_style_decision_gguf import JevStyleDecisionGGUF
+
+m = JevStyleDecisionGGUF(".", quant="F16")      # or "Q8_0", "Q4_K_M"
+r = m.decide(
+    {"ticket": "I was charged twice for my subscription this month.", "customer_tier": "pro"},
+    "Which team should handle this ticket?",
+    options={"billing": "payments, invoices, refunds", "technical": "bugs and outages", "sales": "new purchases"},
+    category="theme_routing",
+)
+print(r["answer"], r["probabilities"])
+m.close()
+```
+
+- `jev-score` (`jev_score.cpp`) is a small libllama program that runs as a JSON-lines process. It requests logits
+  only at the slot positions. With a shared prefix it decodes the state once and scores several questions on
+  copies of it.
+- `decide_many` sends all questions about one state in one request. The default, `many_mode="exact"`, returns
+  exactly what one `decide` call per question returns; it shares the state in whole 1,024-token blocks, so it
+  saves time from 1,024-token states on. `many_mode="batched"` reads the whole state once and scores all questions
+  together (the setting of the latency chart); its probabilities differed from `decide` by at most 0.002 in our
+  tests, and a near-tied top answer can change.
+- The runtime opens a 32,768-token context, which covers the 25,600-token input limit plus the question part.
+  The whole input may be up to 25,600 tokens, and the question, options and readout up to 2,048. Over-budget
+  inputs raise an error, and nothing is truncated.
+- The input format, the readout and the calibration temperatures are described on the
+  [main card](https://huggingface.co/chaoliangUNSW/Jev-Style-0.8B-Decision-v3#input-format-and-readout).
+
+## Licence
+
+Apache-2.0. Built on Qwen/Qwen3.5-0.8B (Apache-2.0). Some training data has restrictive or unclear terms, and some
+training rows are outputs of OpenAI and Anthropic models. See "Training data and licences" on the main card.
+Not affiliated with TypeSafe AI, Jev, the Laya authors or the Qwen team.
+
+## Contact
+
+I welcome internship, employment, and research collaboration opportunities. Please contact me at [**yanchaoliang369@gmail.com**](mailto:yanchaoliang369@gmail.com).
+
+欢迎提供实习、工作及科研合作机会，请邮件联系：[yanchaoliang369@gmail.com](mailto:yanchaoliang369@gmail.com)。

build_jev_score.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+# Build jev-score (jev_score.cpp) against a llama.cpp checkout.
+#   sh build_jev_score.sh /path/to/llama.cpp          -> ./build/jev-score
+# Tested with llama.cpp commit 441df11f65ea0b6d0c72965aaf70c8241070ddcb (2026-09-23), macOS/Metal.
+# If llama.cpp has no shared-library build yet, it is configured and built first (Metal on macOS;
+# pass extra CMake flags in LLAMA_CMAKE_FLAGS, e.g. "-DGGML_CUDA=ON" on Linux/CUDA).
+# OUT=/some/path/jev-score overrides the output file.
+set -eu
+LC=${1:?usage: sh build_jev_score.sh /path/to/llama.cpp}
+LC=$(cd "$LC" && pwd)
+HERE=$(cd "$(dirname "$0")" && pwd)
+OUT=${OUT:-"$HERE/build/jev-score"}
+LIBDIR="$LC/build/bin"
+if [ ! -f "$LIBDIR/libllama.dylib" ] && [ ! -f "$LIBDIR/libllama.so" ]; then
+  cmake -S "$LC" -B "$LC/build" -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON \
+        -DLLAMA_BUILD_TESTS=OFF -DLLAMA_BUILD_SERVER=OFF -DLLAMA_CURL=OFF ${LLAMA_CMAKE_FLAGS:-}
+  cmake --build "$LC/build" -j 8 --target llama
+fi
+if [ ! -f "$LIBDIR/libllama.dylib" ] && [ ! -f "$LIBDIR/libllama.so" ]; then
+  LIBDIR=$(dirname "$(find "$LC/build" -name 'libllama.so' -o -name 'libllama.dylib' | head -n 1)")
+fi
+mkdir -p "$(dirname "$OUT")"
+c++ -std=c++17 -O2 -Wall -Wno-unused-function \
+  -I"$LC/include" -I"$LC/ggml/include" -I"$LC/vendor" \
+  "$HERE/jev_score.cpp" -o "$OUT" \
+  -L"$LIBDIR" -lllama -lggml -lggml-base -Wl,-rpath,"$LIBDIR"
+echo "$OUT"

figures/latency.data.json

@@ -0,0 +1,51 @@
+{
+ "chart": "latency",
+ "from_chart_data_entry": "latency.idle",
+ "source_path": "runs/macjev/latency/m1max_untrained_base_2026-09-23_review_idle/latency.json",
+ "field": "results['llamacpp-f16'|'laya-multilingual-mps-fp32'][cell].p50_ms",
+ "protocol_label": "M1 Max 64 GB, warm end-to-end p50 ms, idle run 2026-09-23 (load avg 3-8); untrained identical-architecture Qwen3.5-0.8B export (latency does not depend on weights); v3 = llama.cpp GGUF F16, one call per state; comparison engine = round-1 MacLaya-4K (our Laya-multilingual fine-tune, FP32/MPS, 4,096-token budget), one decide() per question; prefix reuse off",
+ "plotted": [
+  {
+   "cell": "1024x5",
+   "v3_p50_ms": 394,
+   "maclaya4k_p50_ms": 543,
+   "speedup_label": "1.4x"
+  },
+  {
+   "cell": "1024x10",
+   "v3_p50_ms": 525,
+   "maclaya4k_p50_ms": 1019,
+   "speedup_label": "1.9x"
+  },
+  {
+   "cell": "4096x5",
+   "v3_p50_ms": 1212,
+   "maclaya4k_p50_ms": 3204,
+   "speedup_label": "2.6x"
+  },
+  {
+   "cell": "4096x10",
+   "v3_p50_ms": 1381,
+   "maclaya4k_p50_ms": 6364,
+   "speedup_label": "4.6x"
+  },
+  {
+   "cell": "8192x1",
+   "v3_p50_ms": 2295,
+   "maclaya4k_p50_ms": null,
+   "speedup_label": "v3 only"
+  },
+  {
+   "cell": "8192x5",
+   "v3_p50_ms": 2424,
+   "maclaya4k_p50_ms": null,
+   "speedup_label": "v3 only"
+  },
+  {
+   "cell": "8192x10",
+   "v3_p50_ms": 2613,
+   "maclaya4k_p50_ms": null,
+   "speedup_label": "v3 only"
+  }
+ ]
+}

figures/quantization.data.json

@@ -0,0 +1,151 @@
+{
+ "chart": "quantization",
+ "metric": "top-1 agreement with the full-precision reference (%), plus file size (GB = bytes/1e9)",
+ "rows": [
+  {
+   "tier": "16-bit",
+   "model": "v3",
+   "label": "Jev-Style 0.8B v3 \u00b7 GGUF F16",
+   "agree": 100.0,
+   "n": 240,
+   "agree_count": 240,
+   "size_gb": 1.516744128,
+   "size_note": "local export file (bytes / 1e9)",
+   "reference": "torch FP32",
+   "source": "runs/macjev/export_r2/main/parity/report.json; sizes: chart_data.json export.sizes"
+  },
+  {
+   "tier": "16-bit",
+   "model": "v3",
+   "label": "Jev-Style 0.8B v3 \u00b7 MLX bf16",
+   "agree": 100.0,
+   "n": 240,
+   "agree_count": 240,
+   "size_gb": 1.504827355,
+   "size_note": "local export file (bytes / 1e9)",
+   "reference": "torch FP32",
+   "source": "runs/macjev/export_r2/main/parity/report.json; sizes: chart_data.json export.sizes"
+  },
+  {
+   "tier": "16-bit",
+   "model": "v2",
+   "label": "Jev-Style 2B v2 \u00b7 GGUF BF16",
+   "agree": 99.6,
+   "n": 500,
+   "size_gb": 3.78,
+   "size_note": "as reported on card",
+   "reference": "CUDA merged BF16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2-GGUF/raw/main/README.md"
+  },
+  {
+   "tier": "16-bit",
+   "model": "v2",
+   "label": "Jev-Style 2B v2 \u00b7 MLX BF16",
+   "agree": 99.6,
+   "n": 500,
+   "size_gb": 3.76,
+   "size_note": "as reported on card",
+   "reference": "CUDA merged BF16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2-GGUF/raw/main/README.md (table: 'Native MLX BF16 | 3.76 GB | 99.6% choice agreement')"
+  },
+  {
+   "tier": "16-bit",
+   "model": "v1",
+   "label": "Jev-Style 2B v1 \u00b7 GGUF BF16",
+   "agree": 99.8,
+   "n": 500,
+   "size_gb": 3.9,
+   "size_note": "as reported on card",
+   "reference": "bf16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-GGUF/raw/main/README.md"
+  },
+  {
+   "tier": "8-bit",
+   "model": "v3",
+   "label": "Jev-Style 0.8B v3 \u00b7 GGUF Q8_0",
+   "agree": 100.0,
+   "n": 240,
+   "agree_count": 240,
+   "size_gb": 0.811843008,
+   "size_note": "local export file (bytes / 1e9)",
+   "reference": "torch FP32",
+   "source": "runs/macjev/export_r2/main/parity/report.json; sizes: chart_data.json export.sizes"
+  },
+  {
+   "tier": "8-bit",
+   "model": "v3",
+   "label": "Jev-Style 0.8B v3 \u00b7 MLX 8-bit",
+   "agree": 100.0,
+   "n": 240,
+   "agree_count": 240,
+   "size_gb": 0.799973748,
+   "size_note": "local export file (bytes / 1e9)",
+   "reference": "torch FP32",
+   "source": "runs/macjev/export_r2/main/parity/report.json; sizes: chart_data.json export.sizes"
+  },
+  {
+   "tier": "8-bit",
+   "model": "v2",
+   "label": "Jev-Style 2B v2 \u00b7 GGUF Q8_0",
+   "agree": 99.2,
+   "n": 500,
+   "size_gb": 2.01,
+   "size_note": "as reported on card",
+   "reference": "CUDA merged BF16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2-GGUF/raw/main/README.md"
+  },
+  {
+   "tier": "8-bit",
+   "model": "v1",
+   "label": "Jev-Style 2B v1 \u00b7 GGUF Q8_0",
+   "agree": 99.4,
+   "n": 500,
+   "size_gb": 2.1,
+   "size_note": "as reported on card",
+   "reference": "bf16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-GGUF/raw/main/README.md"
+  },
+  {
+   "tier": "4-bit",
+   "model": "v3",
+   "label": "Jev-Style 0.8B v3 \u00b7 GGUF Q4_K_M",
+   "agree": 100.0,
+   "n": 240,
+   "agree_count": 240,
+   "size_gb": 0.529296832,
+   "size_note": "local export file (bytes / 1e9)",
+   "reference": "torch FP32",
+   "source": "runs/macjev/export_r2/main/parity/report.json; sizes: chart_data.json export.sizes"
+  },
+  {
+   "tier": "4-bit",
+   "model": "v2",
+   "label": "Jev-Style 2B v2 \u00b7 GGUF Q4_K_M",
+   "agree": 91.4,
+   "n": 500,
+   "size_gb": 1.27,
+   "size_note": "as reported on card",
+   "reference": "CUDA merged BF16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2-GGUF/raw/main/README.md"
+  },
+  {
+   "tier": "4-bit",
+   "model": "v1",
+   "label": "Jev-Style 2B v1 \u00b7 GGUF Q4_K_M",
+   "agree": 94.39999999999999,
+   "n": 500,
+   "size_gb": 1.3,
+   "size_note": "as reported on card",
+   "reference": "bf16",
+   "source": "https://huggingface.co/chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-GGUF/raw/main/README.md"
+  }
+ ],
+ "deltas": {
+  "v2 Q4_K_M size / v3 Q4_K_M size": 2.4
+ },
+ "no_agreement_delta_claimed": "v3 parity rows are training-pool rows; v1/v2 used 500 held-out decisions, so no agreement gap is claimed",
+ "long_points": "v3 formats also 100% top-1 at 16,384 and 25,600 tokens (3 rows each), parity report long_points",
+ "not_plotted": "mlx-4bit (98.75%, 237/240) is not a published format and is omitted",
+ "footnote": "v3: top-1 agreement with the PyTorch FP32 reference on a 240-row parity fixture drawn from the training pool (22 categories, en+zh), plus 6 extra rows at about 16K and 25.6K tokens (6/6 agree). v3 sizes = exported weight files (GB = 10^9 bytes). 2B v1/v2: as reported on their public HF GGUF cards (500 held-out decisions each; vs bf16 for v1, vs CUDA merged BF16 for v2; card sizes). Different fixtures (training-pool rows for v3, held-out rows for v1/v2) and references: rows are not a paired comparison. x-axis starts at 88%.",
+ "protocol_label": "v3 G5 parity: 240-row mixed fixture (drawn from training-pool rows, 22 categories, en+zh) vs torch FP32; plus 16K and 25.6K long points (3 rows each). 2B numbers are from their cards on different fixtures (500 decisions vs bf16)"
+}

jev_score.cpp

@@ -0,0 +1,367 @@
+// Part of Jev-Style-0.8B-Decision-v3 (Apache-2.0). Tested against llama.cpp commit
+// 441df11f65ea0b6d0c72965aaf70c8241070ddcb (2026-09-23); needs a llama.cpp with qwen35 support and
+// llama_context_params.n_outputs_max. Build: sh build_jev_score.sh /path/to/llama.cpp
+//
+// jev-score: score Jev-Style typed decisions with libllama, reading logits only at slot positions.
+//
+// Persistent JSON-lines server. Start:
+//   jev-score --model model.gguf [--n-ctx 32768] [--n-ubatch 1024] [--ngl 999] [--threads 8]
+//                [--flash-attn auto|on|off] [--n-outputs-max 256] [--n-seq-max 17]
+// It prints one line {"ready":true,...}. Then each stdin line is one request:
+//   {"prefix":[ids], "questions":[{"ids":[ids], "slots":[abs positions], "rows":[token ids]}],
+//    "share_prefix":true, "keep_prefix":true}
+// Positions in "slots" are absolute in prefix+question ids and must lie inside the question part.
+// For every slot the response returns the logits of the requested token ids only:
+//   {"results":[{"scores":[[...len(rows)] per slot], "finite":true}], "prefix_reused":false,
+//    "n_prefix":N, "timing":{"prefix_ms":..,"question_ms":[..],"total_ms":..}}
+//
+// Mechanics: only slot positions get batch.logits[i] = 1 (never all-token output). With
+// share_prefix the prefix is decoded once into sequence 0 and each question is decoded in
+// sequence 1 after llama_memory_seq_cp(0 -> 1) (attention KV cells are shared; the recurrent
+// GDN state is copied on write by llama.cpp), then sequence 1 is removed. With keep_prefix the
+// prefix stays in sequence 0 and an identical prefix in the next request is reused without
+// recomputation (recurrent state cannot be rolled back, so only exact matches are reused).
+// share_prefix=false decodes prefix+question from scratch per question (reference path).
+// "mode" (default "auto"): with share_prefix, "sequential" = one question at a time as above;
+// "batched" = questions k=1..G get sequences k (seq_cp 0 -> k) and ALL their tokens go into one
+// llama_decode (groups bounded by --n-seq-max - 1 questions, by free KV cells and by
+// --n-outputs-max slots per decode: libllama aborts the process on a larger output request);
+// "auto" = "fused" for a single question whose prefix is not cached (one decode of
+// prefix+question into sequence 0, prefix not kept), "batched" for several questions.
+// {"cmd":"reset"} clears the memory; {"cmd":"quit"} exits.
+
+#include "llama.h"
+#include "nlohmann/json.hpp"
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using json = nlohmann::json;
+using clk = std::chrono::steady_clock;
+
+static double ms_since(clk::time_point t0) {
+    return std::chrono::duration<double, std::milli>(clk::now() - t0).count();
+}
+
+struct Scorer {
+    llama_model * model = nullptr;
+    llama_context * ctx = nullptr;
+    int n_ctx = 0, n_batch = 0, n_vocab = 0, n_seq_max = 2;
+    // Max logits rows one llama_decode may request. libllama GGML_ASSERTs (process abort) when a
+    // batch asks for more, so every decode is kept within it: a single question with more slots
+    // is rejected with an error, batched groups are split by their total slot count.
+    int n_outputs_max = 256;
+    std::vector<llama_token> cached_prefix;   // content of sequence 0
+    bool cached_valid = false;
+
+    void clear() {
+        llama_memory_clear(llama_get_memory(ctx), true);
+        cached_prefix.clear();
+        cached_valid = false;
+    }
+
+    // Decode ids at positions [pos0, pos0+n) into seq; request logits at the given absolute positions.
+    // Returns the batch index of every requested position (same order as `want`).
+    std::vector<int> decode(const std::vector<llama_token> & ids, int pos0, llama_seq_id seq,
+                            const std::vector<int> & want) {
+        std::vector<int> idx(want.size(), -1);
+        const int n = (int) ids.size();
+        if (n == 0) return idx;
+        // Chunk by n_batch (only the last chunk can hold slots because slots lie in the question).
+        for (int start = 0; start < n; start += n_batch) {
+            const int len = std::min(n_batch, n - start);
+            llama_batch batch = llama_batch_init(len, 0, 1);
+            batch.n_tokens = len;
+            for (int j = 0; j < len; ++j) {
+                batch.token[j] = ids[start + j];
+                batch.pos[j] = pos0 + start + j;
+                batch.n_seq_id[j] = 1;
+                batch.seq_id[j][0] = seq;
+                batch.logits[j] = 0;
+            }
+            for (size_t w = 0; w < want.size(); ++w) {
+                const int rel = want[w] - pos0 - start;
+                if (rel >= 0 && rel < len) {
+                    batch.logits[rel] = 1;
+                    idx[w] = rel;
+                }
+            }
+            const int rc = llama_decode(ctx, batch);
+            llama_batch_free(batch);
+            if (rc != 0) throw std::runtime_error("llama_decode failed with code " + std::to_string(rc));
+            for (size_t w = 0; w < want.size(); ++w) {
+                const int rel = want[w] - pos0 - start;
+                if ((rel >= 0 && rel < len) && start + len < n) {
+                    throw std::runtime_error("slot inside a non-final chunk; question longer than n_batch");
+                }
+            }
+        }
+        return idx;
+    }
+
+    // Decode several questions at once: question k goes to sequence seqs[k] at positions
+    // n_prefix.. . Returns per question the batch indices of its slots.
+    std::vector<std::vector<int>> decode_group(const std::vector<std::vector<llama_token>> & ids,
+                                               const std::vector<std::vector<int>> & slots,
+                                               const std::vector<llama_seq_id> & seqs, int n_prefix) {
+        int total = 0;
+        for (const auto & v : ids) total += (int) v.size();
+        if (total > n_batch) throw std::runtime_error("question group larger than n_batch");
+        llama_batch batch = llama_batch_init(total, 0, 1);
+        batch.n_tokens = total;
+        std::vector<std::vector<int>> idx(ids.size());
+        int j = 0;
+        for (size_t k = 0; k < ids.size(); ++k) {
+            std::vector<int> want = slots[k];
+            idx[k].assign(want.size(), -1);
+            for (size_t t = 0; t < ids[k].size(); ++t, ++j) {
+                batch.token[j] = ids[k][t];
+                batch.pos[j] = n_prefix + (int) t;
+                batch.n_seq_id[j] = 1;
+                batch.seq_id[j][0] = seqs[k];
+                batch.logits[j] = 0;
+                for (size_t w = 0; w < want.size(); ++w) {
+                    if (want[w] == n_prefix + (int) t) { batch.logits[j] = 1; idx[k][w] = j; }
+                }
+            }
+        }
+        const int rc = llama_decode(ctx, batch);
+        llama_batch_free(batch);
+        if (rc != 0) throw std::runtime_error("llama_decode (question group) failed with code " + std::to_string(rc));
+        return idx;
+    }
+
+    json read_slots(const std::vector<int> & idx, const std::vector<llama_token> & rows, bool & finite) {
+        json scores = json::array();
+        for (int i : idx) {
+            const float * lg = llama_get_logits_ith(ctx, i);
+            if (!lg) throw std::runtime_error("no logits at requested slot");
+            json r = json::array();
+            for (llama_token t : rows) {
+                if (t < 0 || t >= n_vocab) throw std::runtime_error("row token id out of range");
+                const float v = lg[t];
+                if (!std::isfinite(v)) finite = false;
+                r.push_back(std::isfinite(v) ? json(v) : json(nullptr));
+            }
+            scores.push_back(r);
+        }
+        return scores;
+    }
+
+    json handle(const json & req) {
+        const auto t_total = clk::now();
+        std::vector<llama_token> prefix = req.value("prefix", std::vector<llama_token>{});
+        const bool share = req.value("share_prefix", true);
+        const bool keep = req.value("keep_prefix", true);
+        const json & qs = req.at("questions");
+        llama_memory_t mem = llama_get_memory(ctx);
+        const int n_prefix = (int) prefix.size();
+        json out;
+        json results = json::array();
+        json q_ms = json::array();
+        double prefix_ms = 0.0;
+        bool reused = false;
+
+        for (const auto & q : qs) {
+            std::vector<llama_token> ids = q.at("ids").get<std::vector<llama_token>>();
+            if (n_prefix + (int) ids.size() > n_ctx) {
+                throw std::runtime_error("input of " + std::to_string(n_prefix + ids.size()) +
+                                         " tokens exceeds n_ctx=" + std::to_string(n_ctx) + "; nothing truncated");
+            }
+            const std::vector<int> qslots = q.at("slots").get<std::vector<int>>();
+            if ((int) qslots.size() > n_outputs_max) {
+                throw std::runtime_error("question has " + std::to_string(qslots.size()) + " slots; n_outputs_max=" +
+                                         std::to_string(n_outputs_max) + " (restart with a larger --n-outputs-max)");
+            }
+            for (int s : qslots) {
+                if (s < n_prefix || s >= n_prefix + (int) ids.size())
+                    throw std::runtime_error("slot position outside the question part");
+            }
+        }
+
+        if (share && n_prefix > 0 && keep && cached_valid && cached_prefix == prefix) reused = true;
+        std::string mode = req.value("mode", std::string("auto"));
+        if (mode == "auto") mode = qs.size() > 1 ? "batched" : "fused";
+        if (!share) mode = "sequential";
+        if (mode == "fused" && (qs.size() != 1 || reused)) mode = qs.size() > 1 ? "batched" : "sequential";
+        if (mode == "batched" && n_seq_max < 3) mode = "sequential";
+        std::vector<json> res_by_q(qs.size());
+        std::vector<double> ms_by_q(qs.size(), 0.0);
+
+        if (mode == "fused") {
+            // one decode of prefix + question into sequence 0; the prefix is not kept afterwards
+            const auto t0 = clk::now();
+            const auto & q = qs[0];
+            std::vector<llama_token> all(prefix);
+            std::vector<llama_token> ids = q.at("ids").get<std::vector<llama_token>>();
+            all.insert(all.end(), ids.begin(), ids.end());
+            clear();
+            std::vector<int> idx = decode(all, 0, 0, q.at("slots").get<std::vector<int>>());
+            bool finite = true;
+            json scores = read_slots(idx, q.at("rows").get<std::vector<llama_token>>(), finite);
+            clear();
+            ms_by_q[0] = ms_since(t0);
+            res_by_q[0] = {{"scores", scores}, {"finite", finite}};
+        } else {
+            if (share && n_prefix > 0 && !reused) {
+                const auto t0 = clk::now();
+                clear();
+                decode(prefix, 0, 0, {});
+                llama_synchronize(ctx);
+                prefix_ms = ms_since(t0);
+                cached_prefix = prefix;
+                cached_valid = true;
+            }
+            size_t i = 0;
+            while (i < qs.size()) {
+                const auto t0 = clk::now();
+                // group: up to n_seq_max-1 questions whose tokens fit the free KV cells and n_batch
+                // and whose slots together stay within n_outputs_max (one llama_decode)
+                std::vector<size_t> grp;
+                int used = 0, outs = 0;
+                const int cap = mode == "batched" ? n_seq_max - 1 : 1;
+                while (i < qs.size() && (int) grp.size() < cap) {
+                    const int len = (int) qs[i].at("ids").size();
+                    const int ns = (int) qs[i].at("slots").size();
+                    if (!grp.empty() && (n_prefix + used + len > n_ctx || used + len > n_batch ||
+                                         outs + ns > n_outputs_max)) break;
+                    grp.push_back(i++);
+                    used += len;
+                    outs += ns;
+                }
+                std::vector<std::vector<llama_token>> ids;
+                std::vector<std::vector<int>> slots;
+                std::vector<llama_seq_id> seqs;
+                for (size_t k = 0; k < grp.size(); ++k) {
+                    const llama_seq_id sq = (llama_seq_id) (k + 1);
+                    llama_memory_seq_rm(mem, sq, -1, -1);
+                    if (share && n_prefix > 0) llama_memory_seq_cp(mem, 0, sq, -1, -1);
+                    ids.push_back(qs[grp[k]].at("ids").get<std::vector<llama_token>>());
+                    slots.push_back(qs[grp[k]].at("slots").get<std::vector<int>>());
+                    seqs.push_back(sq);
+                }
+                std::vector<std::vector<int>> idx;
+                if (share) {
+                    idx = decode_group(ids, slots, seqs, n_prefix);
+                } else {    // reference path: prefix + question from scratch
+                    clear();
+                    std::vector<llama_token> all(prefix);
+                    all.insert(all.end(), ids[0].begin(), ids[0].end());
+                    idx.push_back(decode(all, 0, 1, slots[0]));
+                }
+                for (size_t k = 0; k < grp.size(); ++k) {
+                    bool finite = true;
+                    json scores = read_slots(idx[k], qs[grp[k]].at("rows").get<std::vector<llama_token>>(), finite);
+                    res_by_q[grp[k]] = {{"scores", scores}, {"finite", finite}};
+                }
+                for (auto sq : seqs) llama_memory_seq_rm(mem, sq, -1, -1);
+                const double per = ms_since(t0) / (double) grp.size();
+                for (size_t k : grp) ms_by_q[k] = per;
+            }
+        }
+        for (size_t k = 0; k < qs.size(); ++k) {
+            results.push_back(res_by_q[k]);
+            q_ms.push_back(ms_by_q[k]);
+        }
+        out["mode"] = mode;
+        if (!share || !keep) clear();
+        out["results"] = results;
+        out["prefix_reused"] = reused;
+        out["n_prefix"] = n_prefix;
+        out["timing"] = {{"prefix_ms", prefix_ms}, {"question_ms", q_ms}, {"total_ms", ms_since(t_total)}};
+        return out;
+    }
+};
+
+static void usage() {
+    fprintf(stderr, "usage: jev-score --model PATH [--n-ctx N] [--n-ubatch N] [--ngl N] [--threads N] "
+                    "[--flash-attn auto|on|off] [--n-outputs-max N] [--n-seq-max N]\n");
+}
+
+int main(int argc, char ** argv) {
+    std::string model_path, fa = "auto";
+    int n_ctx = 32768, n_ubatch = 1024, ngl = 999, threads = 8, n_out = 256, n_seq = 17;  // 25,600-token context + question room
+    for (int i = 1; i < argc; ++i) {
+        std::string a = argv[i];
+        auto next = [&]() -> std::string {
+            if (i + 1 >= argc) { usage(); exit(2); }
+            return argv[++i];
+        };
+        if (a == "--model") model_path = next();
+        else if (a == "--n-ctx") n_ctx = std::stoi(next());
+        else if (a == "--n-ubatch") n_ubatch = std::stoi(next());
+        else if (a == "--ngl") ngl = std::stoi(next());
+        else if (a == "--threads") threads = std::stoi(next());
+        else if (a == "--flash-attn") fa = next();
+        else if (a == "--n-outputs-max") n_out = std::stoi(next());
+        else if (a == "--n-seq-max") n_seq = std::stoi(next());
+        else { usage(); return 2; }
+    }
+    if (model_path.empty()) { usage(); return 2; }
+    if (n_out < std::max(2, n_seq)) {   // libllama reserves max(n_outputs, n_seq_max) rows and asserts on it
+        std::cout << json{{"ready", false}, {"error", "--n-outputs-max must be >= --n-seq-max"}}.dump() << std::endl;
+        return 2;
+    }
+
+    const auto t0 = clk::now();
+    llama_log_set([](enum ggml_log_level level, const char * text, void *) {
+        if (level >= GGML_LOG_LEVEL_WARN) fputs(text, stderr);
+    }, nullptr);
+    llama_backend_init();
+    llama_model_params mp = llama_model_default_params();
+    mp.n_gpu_layers = ngl;
+    Scorer S;
+    S.model = llama_model_load_from_file(model_path.c_str(), mp);
+    if (!S.model) { std::cout << json{{"ready", false}, {"error", "model load failed"}}.dump() << std::endl; return 1; }
+    llama_context_params cp = llama_context_default_params();
+    cp.n_ctx = n_ctx;
+    cp.n_batch = n_ctx;
+    cp.n_ubatch = std::min(n_ubatch, n_ctx);
+    cp.n_seq_max = std::max(2, n_seq);
+    cp.n_outputs_max = n_out;
+    cp.n_threads = threads;
+    cp.n_threads_batch = threads;
+    cp.kv_unified = true;
+    cp.no_perf = true;
+    cp.flash_attn_type = fa == "on" ? LLAMA_FLASH_ATTN_TYPE_ENABLED
+                       : fa == "off" ? LLAMA_FLASH_ATTN_TYPE_DISABLED : LLAMA_FLASH_ATTN_TYPE_AUTO;
+    S.ctx = llama_init_from_model(S.model, cp);
+    if (!S.ctx) { std::cout << json{{"ready", false}, {"error", "context init failed"}}.dump() << std::endl; return 1; }
+    S.n_ctx = (int) llama_n_ctx(S.ctx);
+    S.n_batch = (int) llama_n_batch(S.ctx);
+    S.n_seq_max = (int) llama_n_seq_max(S.ctx);
+    S.n_outputs_max = (int) cp.n_outputs_max;
+    S.n_vocab = llama_vocab_n_tokens(llama_model_get_vocab(S.model));
+    char desc[256];
+    llama_model_desc(S.model, desc, sizeof(desc));
+    std::cout << json{{"ready", true}, {"n_ctx", S.n_ctx}, {"n_batch", S.n_batch}, {"n_ubatch", cp.n_ubatch}, {"n_seq_max", S.n_seq_max}, {"n_outputs_max", S.n_outputs_max},
+                      {"n_vocab", S.n_vocab}, {"desc", desc}, {"load_ms", ms_since(t0)},
+                      {"system_info", llama_print_system_info()}}.dump() << std::endl;
+
+    std::string line;
+    while (std::getline(std::cin, line)) {
+        if (line.empty()) continue;
+        json resp;
+        try {
+            json req = json::parse(line);
+            const std::string cmd = req.value("cmd", "");
+            if (cmd == "quit") break;
+            if (cmd == "reset") { S.clear(); resp = {{"ok", true}}; }
+            else resp = S.handle(req);
+        } catch (const std::exception & e) {
+            try { S.clear(); } catch (...) {}
+            resp = {{"error", e.what()}};
+        }
+        std::cout << resp.dump() << std::endl;
+    }
+    llama_free(S.ctx);
+    llama_model_free(S.model);
+    llama_backend_free();
+    return 0;
+}

jev_style_decision_gguf.py

@@ -0,0 +1,552 @@
+"""Jev-Style-0.8B-Decision-v3: typed decisions with llama.cpp (GGUF F16 / Q8_0 / Q4_K_M).
+
+Self-contained runtime for chaoliangUNSW/Jev-Style-0.8B-Decision-v3 (Apache-2.0). No dependency on any training code:
+rendering, verdict readout and calibration are implemented below and reproduce the reference
+implementation used for evaluation (see release_config.json -> "runtime_parity").
+
+Calibration temperature: with no category (the default) probabilities use the global temperature of
+readout_config.json (temperatures.global = 0.880); pass category=... (CLI --category, JSONL "category")
+for the fitted group temperature of that category's family x question type x option-count bucket, or
+temperature=... to override (1.0 = uncalibrated scores).
+"""
+# ----------------------------------------------------------------------------------------------
+# Shared core (identical in jev_style_decision.py, jev_style_decision_gguf.py and
+# jev_style_decision_mlx.py): input rendering, verdict readout, calibrated probabilities.
+#
+# Input layout ("macjev-render-v1"; token segments are encoded separately and concatenated):
+#
+#   State:\n<state>\n\n
+#   Question [<type>]: <question>\nOptions:\n
+#   - <option 1>\n ... - <option K>\n
+#   Judge each option:\n
+#   <option 1> ->\n ... <option K> ->\n
+#
+# Score of option k = logit(" yes") - logit(" no") at the k-th " ->" token (computed from the final
+# hidden state and the tied embedding rows, float32). Probabilities = softmax(scores / T), where T is
+# the calibration temperature shipped in readout_config.json:
+#   * no category given (the default): T = temperatures.global (the file's global temperature);
+#   * category="..." given: T = the fitted group temperature of (family of that category x question
+#     type x option-count bucket), or temperatures.global when that group was not fitted;
+#   * temperature=... given: that value (1.0 = uncalibrated scores).
+# T is clamped to temperatures.clamp. Text inside the state or options is tokenised with special
+# tokens disabled, so e.g. "<|im_end|>" in user text can never act as a control token.
+#
+# Budgets: whole input <= 25,600 tokens; question + options + readout ("head") <= 2,048 tokens.
+# Larger inputs raise InputBudgetError. Nothing is ever truncated.
+# ----------------------------------------------------------------------------------------------
+import argparse
+import hashlib
+import json
+import math
+import sys
+from pathlib import Path
+
+import numpy as np
+
+MODEL_NAME = "Jev-Style-0.8B-Decision-v3"
+TEMPLATE_VERSION = "macjev-render-v1"
+READOUT_FORMAT = "macjev-readout-v1"
+CONTEXT_LIMIT = 25_600          # state + question + options + readout
+HARD_HEAD_MAX = 2048            # question + options + readout
+QTYPES = ("choice", "score", "noul")
+HERE = Path(__file__).resolve().parent
+
+# calibration families (category prefix -> family), same table the temperatures were fitted with
+FAMILY_BY_CATEGORY_PREFIX = (("typed_official", "typed"), ("typed_synthetic", "typed_synth"), ("general_", "general"),
+                             ("intent", "intent"), ("nli", "nli"), ("theme_", "theme"), ("mac_", "mac"),
+                             ("long_", "long"))
+
+
+class InputBudgetError(ValueError):
+    """The rendered input exceeds a token budget. Nothing was truncated."""
+
+
+class QuestionError(ValueError):
+    """The question/options are malformed."""
+
+
+# -- questions ------------------------------------------------------------------------------------
+def option_names(question):
+    """Canonical option identifiers, in the order the probabilities are returned."""
+    if not isinstance(question, dict):
+        raise QuestionError("question must be a dict {'t', 'ins', 'crit'}")
+    t, crit = question.get("t"), question.get("crit")
+    if not isinstance(question.get("ins"), str) or not question["ins"].strip():
+        raise QuestionError("question text ('ins') must be a non-empty string")
+    if t == "choice":
+        if not isinstance(crit, dict) or not crit:
+            raise QuestionError("choice needs a non-empty dict {option name: description or None}")
+        return [str(k) for k in crit]
+    if t == "score":
+        if not isinstance(crit, list) or not 2 <= len(crit) <= 10:
+            raise QuestionError("score needs a list of 2..10 level descriptions")
+        return [str(i) for i in range(len(crit))]
+    if t == "noul":
+        if crit is not None and not isinstance(crit, dict):
+            raise QuestionError("noul criteria must be None or {'false': ..., 'true': ...}")
+        return ["false", "true"]
+    raise QuestionError(f"unknown question type {t!r} (expected one of {QTYPES})")
+
+
+def make_question(question, options=None, qtype=None):
+    """Build a typed question.
+
+    * ``question`` already a dict {"t", "ins", "crit"}: validated and returned.
+    * ``qtype="choice"`` (default when ``options`` is given): ``options`` = {name: description or None}
+      or a list of names.
+    * ``qtype="score"``: ``options`` = list of 2..10 level descriptions (level 0 first).
+    * ``qtype="noul"`` (default when no options): a true/false statement; ``options`` may be
+      {"false": "...", "true": "..."} to describe the two outcomes.
+    """
+    if isinstance(question, dict):
+        q = dict(question)
+    else:
+        if qtype is None:
+            qtype = "choice" if options is not None else "noul"
+        if qtype == "choice":
+            if isinstance(options, (list, tuple)):
+                if len(set(map(str, options))) != len(options):
+                    raise QuestionError("duplicate option names")
+                crit = {str(o): None for o in options}
+            else:
+                crit = options
+        elif qtype == "score":
+            crit = list(options) if options is not None else None
+        else:
+            crit = options
+        q = {"t": qtype, "ins": question, "crit": crit}
+    option_names(q)
+    return q
+
+
+def serialize_state(state):
+    """Strings pass through unchanged; any other JSON value is serialised (ensure_ascii=False)."""
+    if isinstance(state, str):
+        return state
+    return json.dumps(state, ensure_ascii=False)
+
+
+def _criterion(value):
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False, separators=(", ", ": "), default=str)
+
+
+def render_options(question):
+    t, crit = question["t"], question.get("crit")
+    if t == "choice":
+        return [k if v is None or v == "" else f"{k}: {_criterion(v)}" for k, v in crit.items()]
+    if t == "score":
+        return [f"level {i}: {_criterion(c)}" for i, c in enumerate(crit)]
+    crit = crit or {}
+    false_c, true_c = crit.get("false"), crit.get("true")
+    return ["false: " + (_criterion(false_c) if false_c not in (None, "") else "no, the statement does not hold"),
+            "true: " + (_criterion(true_c) if true_c not in (None, "") else "yes, the statement holds")]
+
+
+# -- tokenizer + renderer -----------------------------------------------------------------------
+class TextEncoder:
+    """HF ``tokenizers`` tokenizer.json; no BOS/EOS, special tokens in text are split (never control tokens)."""
+
+    def __init__(self, tokenizer_json):
+        from tokenizers import Tokenizer
+        self.tk = Tokenizer.from_file(str(tokenizer_json))
+        self.tk.encode_special_tokens = True
+
+    def __call__(self, text):
+        return self.tk.encode(text, add_special_tokens=False).ids
+
+
+class Rendered:
+    __slots__ = ("ids", "prefix_len", "slots", "names", "head_tokens")
+
+    def __init__(self, ids, prefix_len, slots, names, head_tokens):
+        self.ids, self.prefix_len, self.slots, self.names, self.head_tokens = ids, prefix_len, slots, names, head_tokens
+
+
+class Renderer:
+    def __init__(self, encode, readout_cfg, max_len=CONTEXT_LIMIT, head_max=HARD_HEAD_MAX):
+        if readout_cfg.get("format") != READOUT_FORMAT or readout_cfg.get("template") != TEMPLATE_VERSION:
+            raise ValueError("readout_config.json is not a macjev-readout-v1 / macjev-render-v1 config")
+        if readout_cfg.get("readout") != "verdict":
+            raise ValueError("this runtime implements the verdict readout only")
+        if not 0 < int(max_len) <= CONTEXT_LIMIT:
+            raise ValueError(f"max_len must be in 1..{CONTEXT_LIMIT}")
+        if not 0 < int(head_max) <= HARD_HEAD_MAX:
+            raise ValueError(f"head_max must be in 1..{HARD_HEAD_MAX}")
+        self.enc, self.max_len, self.head_max = encode, int(max_len), int(head_max)
+        st = readout_cfg["slot_tokens"]
+        self.yes, self.no, arrow = int(st["yes"]["id"]), int(st["no"]["id"]), int(st["verdict_slot"]["id"])
+        for text, want in ((" yes", self.yes), (" no", self.no), (" ->", arrow)):
+            got = self.enc(text)
+            if got != [want]:
+                raise ValueError(f"tokenizer mismatch: {text!r} -> {got}, readout_config expects [{want}]")
+        self.arrow = [arrow]
+        self.newline = self.enc("\n")
+        self.dash = self.enc("- ")
+        self.judge = self.enc("Judge each option:\n")
+
+    def prefix_ids(self, state):
+        return self.enc("State:\n") + self.enc(serialize_state(state)) + self.enc("\n\n")
+
+    def render(self, state, question, head_max=None, max_len=None):
+        head_max = self.head_max if head_max is None else int(head_max)
+        max_len = self.max_len if max_len is None else min(int(max_len), self.max_len)
+        if head_max > HARD_HEAD_MAX:
+            raise InputBudgetError(f"head_max may not exceed {HARD_HEAD_MAX}")
+        names = option_names(question)
+        opts = [self.enc(o) for o in render_options(question)]
+        suffix = self.enc(f"Question [{question['t']}]: {question['ins']}\nOptions:\n")
+        for o in opts:
+            suffix += self.dash + o + self.newline
+        suffix += self.judge
+        rel = []
+        for o in opts:
+            suffix += o + self.arrow
+            rel.append(len(suffix) - 1)
+            suffix += self.newline
+        if len(suffix) > head_max:
+            raise InputBudgetError(f"question + options + readout need {len(suffix)} tokens; the head budget is "
+                                   f"{head_max} (hard cap {HARD_HEAD_MAX}). Nothing was truncated: shorten the "
+                                   f"question/options or split the options over several questions.")
+        prefix = self.prefix_ids(state)
+        ids = prefix + suffix
+        if len(ids) > max_len:
+            raise InputBudgetError(f"input needs {len(ids)} tokens (state {len(prefix)} + head {len(suffix)}); the "
+                                   f"limit is {max_len} (model maximum {CONTEXT_LIMIT}). Nothing was truncated: "
+                                   f"shorten the state.")
+        return Rendered(ids, len(prefix), [len(prefix) + s for s in rel], names, len(suffix))
+
+
+# -- calibration ----------------------------------------------------------------------------------
+def family(category):
+    for prefix, fam in FAMILY_BY_CATEGORY_PREFIX:
+        if category.startswith(prefix):
+            return fam
+    return "other"
+
+
+def option_bucket(k):
+    return "2" if k <= 2 else "3-5" if k <= 5 else "6-10" if k <= 10 else "11-20" if k <= 20 else "21+"
+
+
+def lookup_temperature(temps, category, qtype, n_options):
+    """Calibration temperature. ``category`` None/"" -> the global temperature; otherwise the fitted
+    group (family(category) x qtype x option bucket), falling back to the global temperature."""
+    g = None
+    if category:
+        g = (temps.get("groups") or {}).get(f"{family(category)}|{qtype}|{option_bucket(n_options)}")
+    t = g["T"] if g else temps.get("global", 1.0)
+    lo, hi = temps.get("clamp", [0.3, 5.0])
+    return float(min(hi, max(lo, t)))
+
+
+def concentration(p):
+    k = len(p)
+    if k < 2:
+        return 1.0
+    ent = -(p * np.log(np.clip(p, 1e-12, 1.0))).sum()
+    return float(np.clip(1.0 - ent / math.log(k), 0.0, 1.0))
+
+
+def _sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for b in iter(lambda: f.read(1 << 22), b""):
+            h.update(b)
+    return h.hexdigest()
+
+
+def verify_manifest(model_dir, only=None):
+    """Re-hash the files listed in manifest.json (all, or those whose path starts with one of ``only``).
+    Documentation (README.md, figures/, assets/) is recorded in the manifest but not checked here, so
+    a card edit never makes the runtime refuse to load."""
+    model_dir = Path(model_dir)
+    man = json.loads((model_dir / "manifest.json").read_text())
+    bad, missing, checked = [], [], 0
+    for name, rec in man["files"].items():
+        if name == "README.md" or name.startswith(("assets/", "figures/")):
+            continue
+        if only and not any(name == o or name.startswith(o.rstrip("/") + "/") for o in only):
+            continue
+        p = model_dir / name
+        if not p.exists():
+            missing.append(name)
+        elif _sha256(p) != rec["sha256"]:
+            bad.append(name)
+        checked += 1
+    return {"ok": not bad and not missing, "checked": checked, "bad": bad, "missing": missing}
+
+
+class DecisionBase:
+    """Backend-independent part. Subclasses implement ``_scores(rendered) -> list[float]`` and may
+    override ``_scores_many(list of rendered) -> list of list[float]`` (several questions, one state).
+
+    Calibration: ``category`` (constructor default or per call) selects the fitted group temperature
+    of that category's family; with no category anywhere, the global temperature of
+    readout_config.json (temperatures.global) is used."""
+    backend = "base"
+
+    def _setup(self, model_dir, tokenizer_json, category=None, head_max=HARD_HEAD_MAX, max_len=CONTEXT_LIMIT):
+        self.model_dir = Path(model_dir)
+        self.readout_config = json.loads((self.model_dir / "readout_config.json").read_text())
+        self.temperatures = self.readout_config["temperatures"]
+        self.default_category = category or None       # None -> temperatures.global
+        self.encode = TextEncoder(tokenizer_json)
+        self.renderer = Renderer(self.encode, self.readout_config, max_len=max_len, head_max=head_max)
+
+    def temperature(self, question, category=None):
+        """T for ``question``: group temperature of ``category`` (or the constructor's default category);
+        the global temperature when neither is given."""
+        return lookup_temperature(self.temperatures, category or self.default_category, question["t"],
+                                  len(option_names(question)))
+
+    def _scores_many(self, rendered):
+        return [self._scores(r) for r in rendered]
+
+    def _result(self, r, q, scores, category=None, temperature=None):
+        scores = [float(x) for x in scores]
+        t = float(temperature) if temperature is not None else self.temperature(q, category)
+        z = np.asarray(scores, float) / t
+        if not np.all(np.isfinite(z)):
+            raise FloatingPointError("non-finite decision scores")
+        p = np.exp(z - z.max())
+        p /= p.sum()
+        i = int(p.argmax())
+        return {"answer": r.names[i], "probabilities": dict(zip(r.names, p.tolist())),
+                "scores": dict(zip(r.names, scores)), "temperature": t, "top_probability": float(p[i]),
+                "entropy_concentration": concentration(p), "input_tokens": len(r.ids), "head_tokens": r.head_tokens,
+                "model": MODEL_NAME, "backend": self.backend}
+
+    def decide(self, state, question, options=None, qtype=None, category=None, temperature=None, head_max=None):
+        """Score one question about ``state``.
+
+        Returns {"answer", "probabilities" {option: p}, "scores" {option: logit(yes)-logit(no)},
+        "temperature", "top_probability", "entropy_concentration", "input_tokens", "head_tokens"}.
+        Temperature: with no ``category`` (here or in the constructor) the global temperature of
+        readout_config.json is used; ``category`` picks the fitted group temperature of its family
+        (e.g. "mac_gate", "general_topic", "theme_routing", "intent", "typed_official");
+        ``temperature`` overrides both (1.0 = uncalibrated scores).
+        Raises InputBudgetError (never truncates) or QuestionError.
+        """
+        q = make_question(question, options, qtype)
+        r = self.renderer.render(state, q, head_max=head_max)
+        return self._result(r, q, self._scores(r), category, temperature)
+
+    def decide_many(self, state, questions, category=None, temperature=None, head_max=None):
+        """Several questions about the same state (each a dict {"t","ins","crit"}); results in order.
+        Same outputs as calling decide() per question. The llama.cpp runtime sends all questions in one
+        request and shares the state in whole 1,024-token ubatches (see JevStyleDecisionGGUF, also for
+        its faster, not bit-identical many_mode="batched"). All questions are rendered and
+        budget-checked before any scoring."""
+        qs = [make_question(q) for q in questions]
+        rs = [self.renderer.render(state, q, head_max=head_max) for q in qs]
+        if not rs:
+            return []
+        return [self._result(r, q, sc, category, temperature) for r, q, sc in zip(rs, qs, self._scores_many(rs))]
+
+
+def base_arg_parser(description):
+    ap = argparse.ArgumentParser(description=description)
+    ap.add_argument("--model-dir", default=str(HERE), help="folder with the weights and readout_config.json")
+    ap.add_argument("--state", help="state as plain text")
+    ap.add_argument("--state-json", help="state as a JSON value")
+    ap.add_argument("--question", help="question text (or a JSON question {'t','ins','crit'})")
+    ap.add_argument("--options", help="JSON: {name: description} or [names] (choice); [levels] (score)")
+    ap.add_argument("--qtype", choices=QTYPES)
+    ap.add_argument("--category", help="calibration family key, e.g. mac_gate, general_topic, theme_routing, intent "
+                                       "(default: none -> the global temperature of readout_config.json)")
+    ap.add_argument("--temperature", type=float, help="override the calibrated temperature")
+    ap.add_argument("--head-max", type=int, default=HARD_HEAD_MAX)
+    ap.add_argument("--max-len", type=int, default=CONTEXT_LIMIT)
+    ap.add_argument("--jsonl", help="batch mode: input JSON lines {id?, state, question, options?, qtype?, "
+                                    "category?}; one JSON result per line on stdout")
+    ap.add_argument("--verify", action="store_true", help="check sha256 of the files in manifest.json first")
+    return ap
+
+
+def run_cli(args, engine):
+    def one(rec):
+        q = rec["question"]
+        return engine.decide(rec.get("state", ""), q, options=rec.get("options"), qtype=rec.get("qtype"),
+                             category=rec.get("category"), temperature=rec.get("temperature", args.temperature))
+    if args.jsonl:
+        src = sys.stdin if args.jsonl == "-" else open(args.jsonl, encoding="utf-8")
+        for n, line in enumerate(src):
+            if not line.strip():
+                continue
+            rec = json.loads(line)
+            rid = rec.get("id", n)
+            try:
+                out = {"id": rid, **one(rec)}
+            except (InputBudgetError, QuestionError) as e:
+                out = {"id": rid, "error": f"{type(e).__name__}: {e}"}
+            print(json.dumps(out, ensure_ascii=False), flush=True)
+        return 0
+    if args.question is None:
+        raise SystemExit("--question (or --jsonl) is required")
+    state = json.loads(args.state_json) if args.state_json is not None else (args.state or "")
+    question = args.question
+    if question.lstrip().startswith("{"):
+        question = json.loads(question)
+    rec = {"state": state, "question": question, "options": json.loads(args.options) if args.options else None,
+           "qtype": args.qtype, "category": args.category}
+    print(json.dumps(one(rec), ensure_ascii=False, indent=2))
+    return 0
+# ---------------------------------------------------------------------------- end of shared core
+
+
+# ---------------------------------------------------------------------------- llama.cpp backend
+import os
+import shutil
+import subprocess
+import threading
+
+GGUF_FILES = {q: f"{MODEL_NAME}-{q}.gguf" for q in ("F16", "Q8_0", "Q4_K_M")}
+LLAMA_N_CTX = 32768        # >= 25,600-token context + room for question suffixes
+assert LLAMA_N_CTX >= CONTEXT_LIMIT + 3 * HARD_HEAD_MAX
+MANY_MODES = ("exact", "batched")
+
+
+def find_scorer(binary=None):
+    """jev-score binary: argument, $JEV_SCORE_BIN, ./build/jev-score, or on PATH."""
+    for cand in (binary, os.environ.get("JEV_SCORE_BIN"), HERE / "build" / "jev-score", shutil.which("jev-score")):
+        if cand and Path(cand).is_file():
+            return Path(cand)
+    raise FileNotFoundError("jev-score binary not found: build it with `sh build_jev_score.sh /path/to/llama.cpp` "
+                            "(see the header of jev_score.cpp), or pass --jev-score / set JEV_SCORE_BIN")
+
+
+class JevStyleDecisionGGUF(DecisionBase):
+    """llama.cpp runtime. The GGUF is run by ``jev-score`` (jev_score.cpp, a ~350-line libllama
+    program shipped in this repo), which reads the " yes" / " no" logits only at the slot positions;
+    this class renders inputs with the shipped tokenizer and applies the readout + calibration.
+
+    quant: "F16" (validated default), "Q8_0" or "Q4_K_M".
+
+    ``decide`` sends one request per question: state + question in one decode ("fused"), the
+    validated path.
+
+    ``decide_many`` sends all questions about one state in ONE jev-score request.
+    many_mode="exact" (default): results are bit-identical to calling ``decide`` per question
+    (and do not depend on which other questions are in the request). llama.cpp decodes in
+    ubatches of n_ubatch (1,024) tokens, and the Gated DeltaNet state and the kernel choice depend
+    on how the input is split, so only whole ubatches of the state can be shared: the first
+    floor(state_tokens / 1024) * 1024 tokens are decoded once and kept, and the rest of the state
+    plus each question is decoded on a copy of it, exactly as ``decide`` splits them. States
+    shorter than 1,024 tokens share nothing (each question recomputes the state, still in one
+    request); the saving grows with the state length.
+    many_mode="batched": the whole state is decoded once and all questions go into one decode
+    (jev-score "batched" mode, the mode of the published latency figures). It is the fastest
+    option but not bit-identical to ``decide``: in our tests probabilities differed by up to 4.4e-4
+    (F16, Q8_0) and 1.7e-3 (Q4_K_M), and a near-tied top answer can change (1 of 201 test pairs on
+    F16 and on Q8_0); see release_config.json -> runtime_parity -> decide_many.
+    """
+    backend = "llama.cpp"
+
+    def __init__(self, model_dir=HERE, quant="F16", gguf=None, binary=None, category=None, head_max=HARD_HEAD_MAX,
+                 max_len=CONTEXT_LIMIT, n_gpu_layers=999, threads=None, flash_attn="auto", n_ubatch=1024,
+                 many_mode="exact", verify=False, stderr=None):
+        if many_mode not in MANY_MODES:
+            raise ValueError(f"many_mode must be one of {MANY_MODES}, got {many_mode!r}")
+        self.many_mode = many_mode
+        model_dir = Path(model_dir)
+        self.gguf = Path(gguf) if gguf else model_dir / GGUF_FILES[quant.upper()]
+        if verify:
+            res = verify_manifest(model_dir, only=["tokenizer", "readout_config.json", self.gguf.name])
+            if not res["ok"]:
+                raise RuntimeError(f"integrity check failed: {res}")
+        self._setup(model_dir, model_dir / "tokenizer" / "tokenizer.json", category, head_max, max_len)
+        self.binary = find_scorer(binary)
+        cmd = [str(self.binary), "--model", str(self.gguf), "--n-ctx", str(LLAMA_N_CTX), "--n-ubatch", str(n_ubatch),
+               "--ngl", str(n_gpu_layers), "--flash-attn", flash_attn, "--n-seq-max", "17", "--n-outputs-max", "256"]
+        if threads:
+            cmd += ["--threads", str(threads)]
+        self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                     stderr=stderr if stderr is not None else subprocess.DEVNULL, text=True, bufsize=1)
+        self._lock = threading.Lock()
+        line = self.proc.stdout.readline()
+        ready = json.loads(line) if line else {"ready": False, "error": "no output (see stderr)"}
+        if not ready.get("ready"):
+            raise RuntimeError(f"jev-score failed to start: {ready}")
+        self.info = ready
+
+    def _request(self, req):
+        with self._lock:
+            self.proc.stdin.write(json.dumps(req) + "\n")
+            self.proc.stdin.flush()
+            line = self.proc.stdout.readline()
+        if not line:
+            raise RuntimeError("jev-score exited")
+        resp = json.loads(line)
+        if "error" in resp:
+            raise RuntimeError(f"jev-score: {resp['error']}")
+        return resp
+
+    def _scores(self, r):
+        rows = [self.renderer.yes, self.renderer.no]
+        resp = self._request({"prefix": r.ids[:r.prefix_len], "share_prefix": True, "keep_prefix": False,
+                              "mode": "fused",
+                              "questions": [{"ids": r.ids[r.prefix_len:], "slots": r.slots, "rows": rows}]})
+        return [float("nan") if (y is None or n is None) else y - n for y, n in resp["results"][0]["scores"]]
+
+    def _shared_len(self, n_prefix):
+        """State tokens decoded once in many_mode="exact": whole ubatches only, so that every ubatch
+        (and with it the Gated DeltaNet chunking and the llama.cpp kernel choice) is exactly the one
+        ``decide`` uses; any other split can change the scores by ~1e-3."""
+        u = int(self.info.get("n_ubatch") or 1024)
+        return (n_prefix // u) * u
+
+    def _scores_many(self, rendered):
+        """All questions of one state in ONE jev-score request (see the class docstring for many_mode)."""
+        if len(rendered) == 1:
+            return [self._scores(rendered[0])]
+        n_prefix = rendered[0].prefix_len
+        prefix = rendered[0].ids[:n_prefix]
+        if any(r.prefix_len != n_prefix or r.ids[:n_prefix] != prefix for r in rendered):
+            return [self._scores(r) for r in rendered]                 # not one state: one by one
+        batched = self.many_mode == "batched"
+        s = n_prefix if batched else self._shared_len(n_prefix)
+        rows = [self.renderer.yes, self.renderer.no]
+        resp = self._request({"prefix": prefix[:s], "share_prefix": s > 0, "keep_prefix": s > 0,
+                              "mode": "batched" if batched else "sequential",
+                              "questions": [{"ids": r.ids[s:], "slots": r.slots, "rows": rows} for r in rendered]})
+        self.last_timing = dict(resp.get("timing") or {}, shared_tokens=s, mode=resp.get("mode"))
+        return [[float("nan") if (y is None or n is None) else y - n for y, n in res["scores"]]
+                for res in resp["results"]]
+
+    def close(self):
+        if getattr(self, "proc", None) and self.proc.poll() is None:
+            try:
+                self.proc.stdin.write('{"cmd":"quit"}\n')
+                self.proc.stdin.flush()
+                self.proc.wait(timeout=10)
+            except Exception:
+                self.proc.kill()
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+
+def main(argv=None):
+    ap = base_arg_parser(f"{MODEL_NAME}: typed decisions with llama.cpp (GGUF)")
+    ap.add_argument("--quant", default="F16", choices=sorted(GGUF_FILES))
+    ap.add_argument("--gguf", help="explicit GGUF path (overrides --quant)")
+    ap.add_argument("--jev-score", help="path to the jev-score binary (default: $JEV_SCORE_BIN, ./build/jev-score)")
+    ap.add_argument("--ngl", type=int, default=999, help="layers offloaded to the GPU")
+    ap.add_argument("--threads", type=int)
+    args = ap.parse_args(argv)
+    engine = JevStyleDecisionGGUF(args.model_dir, quant=args.quant, gguf=args.gguf, binary=args.jev_score,
+                                  category=args.category, head_max=args.head_max, max_len=args.max_len,
+                                  n_gpu_layers=args.ngl, threads=args.threads, verify=args.verify)
+    try:
+        return run_cli(args, engine)
+    finally:
+        engine.close()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

manifest.json

@@ -0,0 +1,89 @@
+{
+  "format": "jev-style-manifest-v1",
+  "repo": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3-GGUF",
+  "created_unix": 1790261967.451401,
+  "files": {
+    "Jev-Style-0.8B-Decision-v3-F16.gguf": {
+      "sha256": "a33f709e10009c3fe182b51e4945d440288b137a35ad5d481e4ac1f2800b1a27",
+      "bytes": 1516744160
+    },
+    "Jev-Style-0.8B-Decision-v3-Q4_K_M.gguf": {
+      "sha256": "0a19bc29bacc33e0d871146c8612b24dd14c2ed2e61cedeb7a928b0852628bac",
+      "bytes": 529296864
+    },
+    "Jev-Style-0.8B-Decision-v3-Q8_0.gguf": {
+      "sha256": "cd87d284c4ee355cb0b3fce7391db57ba3ad108e45b3a41b058d529931a2bd5e",
+      "bytes": 811843040
+    },
+    "LICENSE": {
+      "sha256": "bbedc3fda3305820b977265f01b8619d87570a6739de3a5582c3464840f1e57a",
+      "bytes": 11544
+    },
+    "NOTICE": {
+      "sha256": "5b20e266b5b9b9c12df4cb53db6801bc08fe8f1471355aaec15c1a9f9aa0b201",
+      "bytes": 2585
+    },
+    "README.md": {
+      "sha256": "f39d3a008a7d9285119489551d1993524a9a5083001dd6b65dd2115af9938402",
+      "bytes": 7080
+    },
+    "build_jev_score.sh": {
+      "sha256": "5789a1585c51fbc4a03b423099a451e05cb66b9db49bc6c9361f326aca170fda",
+      "bytes": 1399
+    },
+    "figures/latency.data.json": {
+      "sha256": "c0eb510a69dfe1b1cd85beca6ba3c354be4984d588b4aae2672331606a119cbc",
+      "bytes": 1402
+    },
+    "figures/latency.png": {
+      "sha256": "d6d0d34b875997b8a733d4776dc34a1b564ddc64b48cea9d0def7f72a34af79e",
+      "bytes": 203081
+    },
+    "figures/latency.svg": {
+      "sha256": "c7bdf011eec488aae7197d653cb8486dfd8ccbd1a58f5ba222873de7410aca30",
+      "bytes": 24079
+    },
+    "figures/quantization.data.json": {
+      "sha256": "a140816ef145a6dd096ef471e4afbff1cecd33adb663c6cb856e19845349fc2d",
+      "bytes": 5473
+    },
+    "figures/quantization.png": {
+      "sha256": "bc75c212caa11008ca929a685d3085040c2b4698afb58d04a0ad692b815be230",
+      "bytes": 253992
+    },
+    "figures/quantization.svg": {
+      "sha256": "70720bb46ec1e718dcbfac9a83d3b5d11d50b3a5cc3356915465d70d95f3d43b",
+      "bytes": 28756
+    },
+    "jev_score.cpp": {
+      "sha256": "90d848a61546286c74e484f61126f572b79c6f77f835450d8fc970b8547ce603",
+      "bytes": 18088
+    },
+    "jev_style_decision_gguf.py": {
+      "sha256": "2db954a8a0792668c2d6c051fc8149e695675968cf32c52003f95820fdd95c5a",
+      "bytes": 28332
+    },
+    "readout_config.json": {
+      "sha256": "01de9bcce7effbfd1ae0a3fa13e52d7fa9aa4dd1cd1e47977d6bbdcd5e63054a",
+      "bytes": 6236
+    },
+    "release_config.json": {
+      "sha256": "5e2abbf2cf2e2e6d5b1a33bc299d779933bd1e3eef46321938e10f687d41585a",
+      "bytes": 17114
+    },
+    "requirements.txt": {
+      "sha256": "632dbfd22eefe09f9008e6437f2849c674c067080473eb5e9d7d3f5910f425eb",
+      "bytes": 204
+    },
+    "tokenizer/tokenizer.json": {
+      "sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523",
+      "bytes": 19989325
+    },
+    "tokenizer/tokenizer_config.json": {
+      "sha256": "66e427c470fe580fe8c7b5725d857af23d8417e37fae62667ec698306a19987b",
+      "bytes": 1124
+    }
+  },
+  "readme_hashed": true,
+  "note": "manifest.json hashes every file of the repo except itself, README.md and figures/ included. The runtime --verify check skips the documentation (README.md, figures/, assets/) and checks every other file."
+}

readout_config.json

@@ -0,0 +1,247 @@
+{
+  "format": "macjev-readout-v1",
+  "model_name": "Jev-Style-0.8B-Decision-v3",
+  "readout": "verdict",
+  "template": "macjev-render-v1",
+  "slot_tokens": {
+    "yes": {
+      "text": " yes",
+      "id": 9542
+    },
+    "no": {
+      "text": " no",
+      "id": 874
+    },
+    "verdict_slot": {
+      "text": " ->",
+      "id": 1411
+    },
+    "letters": {
+      "A": 357,
+      "B": 417,
+      "C": 351,
+      "D": 414,
+      "E": 458,
+      "F": 426,
+      "G": 469,
+      "H": 462,
+      "I": 353,
+      "J": 604,
+      "K": 710,
+      "L": 436,
+      "M": 380,
+      "N": 443,
+      "O": 496,
+      "P": 387,
+      "Q": 1167,
+      "R": 423,
+      "S": 326,
+      "T": 345,
+      "U": 533,
+      "V": 629,
+      "W": 457,
+      "X": 1543,
+      "Y": 783,
+      "Z": 1799,
+      "a": 264,
+      "b": 292,
+      "c": 272,
+      "d": 293,
+      "e": 378,
+      "f": 281,
+      "g": 338,
+      "h": 304,
+      "i": 585,
+      "j": 492,
+      "k": 580,
+      "l": 324,
+      "m": 295,
+      "n": 307,
+      "o": 296,
+      "p": 280,
+      "q": 2715,
+      "r": 427,
+      "s": 274,
+      "t": 259,
+      "u": 560,
+      "v": 343,
+      "w": 288,
+      "x": 830,
+      "y": 374,
+      "z": 1110
+    }
+  },
+  "score": "per option k: logit[' yes'] - logit[' no'] at the k-th ' ->' slot, computed as h_slot . (w_yes - w_no) from the final normed hidden state and the tied embedding rows (float32)",
+  "probabilities": "softmax(scores / T); T = temperatures.groups['<family>|<qtype>|<option bucket>'].T (else temperatures.global), clamped to temperatures.clamp",
+  "families": {
+    "typed_official*": "typed",
+    "typed_synthetic*": "typed_synth",
+    "general_*": "general",
+    "intent*": "intent",
+    "nli*": "nli",
+    "theme_*": "theme",
+    "mac_*": "mac",
+    "long_*": "long",
+    "anything else": "other (global T)"
+  },
+  "option_buckets": [
+    "2",
+    "3-5",
+    "6-10",
+    "11-20",
+    "21+"
+  ],
+  "default_category": null,
+  "default_category_note": "no category given -> temperatures.global (the global temperature); pass category=... for the fitted group temperature of that category's family",
+  "tokenizer_sha256": "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523",
+  "budgets": {
+    "max_len": 25600,
+    "head_max": 2048,
+    "hard_head_max": 2048,
+    "note": "whole input <= max_len tokens, question+options+readout <= head_max; larger inputs raise InputBudgetError, nothing is truncated"
+  },
+  "temperatures": {
+    "version": "macjev-temperatures-v1",
+    "global": 0.8800546821789332,
+    "groups": {
+      "general|choice|3-5": {
+        "T": 0.8563796906101172,
+        "T_raw": 0.8524962478467872,
+        "n": 600,
+        "weight": 0.8571428571428571
+      },
+      "general|choice|6-10": {
+        "T": 0.7883347591845132,
+        "T_raw": 0.7797058230459033,
+        "n": 1000,
+        "weight": 0.9090909090909091
+      },
+      "general|noul|2": {
+        "T": 0.9702474579038656,
+        "T_raw": 1.0023209290239254,
+        "n": 300,
+        "weight": 0.75
+      },
+      "general|score|3-5": {
+        "T": 0.9583320444900012,
+        "T_raw": 0.9748039508642105,
+        "n": 500,
+        "weight": 0.8333333333333334
+      },
+      "intent|choice|11-20": {
+        "T": 0.8536586990515279,
+        "T_raw": 0.8530447902066461,
+        "n": 4233,
+        "weight": 0.9769213016385876
+      },
+      "intent|choice|21+": {
+        "T": 0.7508751181814466,
+        "T_raw": 0.737974406022733,
+        "n": 916,
+        "weight": 0.9015748031496063
+      },
+      "long|choice|2": {
+        "T": 1.0101601686032944,
+        "T_raw": 2.5327604766936602,
+        "n": 15,
+        "weight": 0.13043478260869565
+      },
+      "long|choice|3-5": {
+        "T": 0.9789458925825579,
+        "T_raw": 0.9984431087771811,
+        "n": 540,
+        "weight": 0.84375
+      },
+      "long|choice|6-10": {
+        "T": 0.6918332634850016,
+        "T_raw": 0.6260903832047418,
+        "n": 241,
+        "weight": 0.7067448680351907
+      },
+      "long|noul|2": {
+        "T": 0.8183260460233314,
+        "T_raw": 0.7857458244621078,
+        "n": 179,
+        "weight": 0.6415770609318996
+      },
+      "long|score|3-5": {
+        "T": 0.8412851094005789,
+        "T_raw": 0.7952160414763221,
+        "n": 80,
+        "weight": 0.4444444444444444
+      },
+      "mac|choice|3-5": {
+        "T": 0.7640449061346866,
+        "T_raw": 0.753267027600698,
+        "n": 995,
+        "weight": 0.908675799086758
+      },
+      "mac|noul|2": {
+        "T": 0.922463080251143,
+        "T_raw": 0.9300179680535603,
+        "n": 577,
+        "weight": 0.8522895125553914
+      },
+      "mac|score|3-5": {
+        "T": 2.729450780811877,
+        "T_raw": 4.999707266277221,
+        "n": 187,
+        "weight": 0.6515679442508711
+      },
+      "nli|choice|3-5": {
+        "T": 1.003611674961589,
+        "T_raw": 1.0108425661039413,
+        "n": 1830,
+        "weight": 0.9481865284974094
+      },
+      "theme|choice|6-10": {
+        "T": 0.9848729122522978,
+        "T_raw": 0.9981552921230235,
+        "n": 840,
+        "weight": 0.8936170212765957
+      },
+      "theme|noul|2": {
+        "T": 0.896799495386032,
+        "T_raw": 0.89763584528285,
+        "n": 2022,
+        "weight": 0.9528746465598492
+      },
+      "typed|choice|3-5": {
+        "T": 0.9751541851571508,
+        "T_raw": 1.0336976619219436,
+        "n": 176,
+        "weight": 0.6376811594202898
+      },
+      "typed|noul|2": {
+        "T": 0.9892589014450378,
+        "T_raw": 1.054189849787923,
+        "n": 184,
+        "weight": 0.647887323943662
+      },
+      "typed|score|3-5": {
+        "T": 1.0056628114581752,
+        "T_raw": 1.0631515969968885,
+        "n": 240,
+        "weight": 0.7058823529411765
+      }
+    },
+    "clamp": [
+      0.3,
+      5.0
+    ],
+    "shrinkage_k": 100.0,
+    "key": "family|qtype|option_bucket",
+    "n_rows": 15655,
+    "fitted_on": [
+      "pool_cal.jsonl:dfb7e9beff96c6c5"
+    ],
+    "fit_quality": {
+      "nll_before": 0.37752055301970966,
+      "nll_after": 0.36671188108641545,
+      "ece_before": 0.03289307373502533,
+      "ece_after": 0.011376234101433989,
+      "n": 15655
+    }
+  },
+  "temperatures_sha256": "39ad8f6633934ff67770725993d7354ebebd6e7a08f73e50cab04df24715f2ce"
+}

release_config.json

@@ -0,0 +1,425 @@
+{
+  "format": "jev-style-release-v1",
+  "model_name": "Jev-Style-0.8B-Decision-v3",
+  "repo": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3-GGUF",
+  "generation": "v3 (third generation of the Jev-Style decision series)",
+  "lineage": {
+    "v1": "chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision",
+    "v1_public_gguf": "chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-GGUF",
+    "v2": "chaoliangUNSW/Jev-Style-Qwen3.5-2B-Decision-v2",
+    "v3": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3"
+  },
+  "base_model": "Qwen/Qwen3.5-0.8B",
+  "base_model_revision": "2fc06364715b967f1860aea9cf38778875588b17",
+  "base_model_relation": "finetune",
+  "architecture": "Qwen3_5ForCausalLM (text only, 24 layers: 18 Gated DeltaNet + 6 full attention, hidden 1024, tied embeddings, 752,393,024 parameters)",
+  "readout": "verdict",
+  "template": "macjev-render-v1",
+  "readout_config": "readout_config.json",
+  "budgets": {
+    "max_len": 25600,
+    "head_max": 2048
+  },
+  "source": {
+    "checkpoint_sha256": {
+      "best-0.safetensors": "b10d249adfa3e1475f0f633ab961130c06f16c898db23c846b035d24bdc5c945"
+    },
+    "text_only_model_safetensors_sha256": "0f8c861605dcdfb356a63e056baa2106e81042e8981e8d0d26fe50b34599541e",
+    "release_manifest_sha256": "4bc9f89795ccf2d749008de7739bc5294f3ec543404ca2db9cac6a3914cfb84a",
+    "llama_cpp_commit": "441df11f65ea0b6d0c72965aaf70c8241070ddcb",
+    "mlx": "0.32.2",
+    "mlx_lm": "0.31.3"
+  },
+  "calibration": {
+    "version": "macjev-temperatures-v1",
+    "global_T": 0.8800546821789332,
+    "groups": 20,
+    "n_rows": 15655,
+    "fit_quality": {
+      "nll_before": 0.37752055301970966,
+      "nll_after": 0.36671188108641545,
+      "ece_before": 0.03289307373502533,
+      "ece_after": 0.011376234101433989,
+      "n": 15655
+    },
+    "fitted_on": "calibration pool (dev/cal rows, never test rows)"
+  },
+  "g5_parity": {
+    "reference": "PyTorch float32 (same weights, same rendered inputs)",
+    "rows": 240,
+    "rows_note": "non-sealed training-distribution rows, 22 categories, en 215 / zh 25",
+    "report_sha256": "056dc3a3d1de5616f97dab3f8b5ec1f7e2c6c85258aa03f2a57b9fd65a71022b",
+    "g5_pass": true,
+    "verdict_readout": {
+      "gguf-f16": {
+        "top1_agreement": 1.0,
+        "dnll": 2.436279701012456e-05,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "top1>=0.99, |dNLL|<=0.02, no NaN, every reference row scored",
+        "pass": true
+      },
+      "gguf-q8_0": {
+        "top1_agreement": 1.0,
+        "dnll": -3.093173930673876e-05,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "top1>=0.98, |dNLL|<=0.02, no NaN, every reference row scored",
+        "pass": true
+      },
+      "gguf-q4_k_m": {
+        "top1_agreement": 1.0,
+        "dnll": 0.006187511546346225,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "report_only",
+        "pass": true
+      },
+      "mlx-bf16": {
+        "top1_agreement": 1.0,
+        "dnll": 0.00031018251516545803,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "top1>=0.99, |dNLL|<=0.02, no NaN, every reference row scored",
+        "pass": true
+      },
+      "mlx-bf16-f32act": {
+        "top1_agreement": 1.0,
+        "dnll": 0.00015659911501769708,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "top1>=0.99, |dNLL|<=0.02, no NaN, every reference row scored",
+        "pass": true
+      },
+      "mlx-8bit": {
+        "top1_agreement": 1.0,
+        "dnll": 0.00023178691602621093,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "top1>=0.98, |dNLL|<=0.02, no NaN, every reference row scored",
+        "pass": true
+      },
+      "mlx-4bit": {
+        "top1_agreement": 0.9875,
+        "dnll": 0.010326217052955111,
+        "n": 240,
+        "nan_rows": 0,
+        "gate": "report_only",
+        "pass": true
+      }
+    },
+    "gates": "top-1 >= 0.99 (16-bit) / >= 0.98 (8-bit), |dNLL| <= 0.02, no NaN; 4-bit report-only"
+  },
+  "decision_index": "not run for this release (optional follow-up)",
+  "related_repos": {
+    "main": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3",
+    "gguf": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3-GGUF",
+    "mlx-bf16": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3-MLX-bf16",
+    "mlx-8bit": "chaoliangUNSW/Jev-Style-0.8B-Decision-v3-MLX-8bit"
+  },
+  "not_released": {
+    "mlx-4bit": "affine4-g64 reported only (G5 top-1 0.9875, report-only gate); not released"
+  },
+  "tested_with": {
+    "python": "3.12",
+    "torch": "2.14.0",
+    "transformers": "5.17.0",
+    "tokenizers": "0.23.2",
+    "numpy": "2.5.3",
+    "mlx": "0.32.2",
+    "mlx-lm": "0.31.3",
+    "llama.cpp": "441df11f65ea0b6d0c72965aaf70c8241070ddcb"
+  },
+  "weights": {
+    "Jev-Style-0.8B-Decision-v3-F16.gguf": "F16",
+    "Jev-Style-0.8B-Decision-v3-Q8_0.gguf": "Q8_0",
+    "Jev-Style-0.8B-Decision-v3-Q4_K_M.gguf": "Q4_K_M"
+  },
+  "runtime": {
+    "script": "jev_style_decision_gguf.py",
+    "class": "JevStyleDecisionGGUF",
+    "engine": "jev-score (jev_score.cpp, libllama; slot-only logits)",
+    "default_quant": "F16",
+    "n_ctx": 32768
+  },
+  "gguf_metadata_edit": {
+    "what": "general.name set to 'Jev-Style-0.8B-Decision-v3' (metadata only; the exported files had 'Text Only'); tensor data byte-identical",
+    "tool": "gguf-py scripts/gguf_new_metadata.py, llama.cpp 441df11f65ea0b6d0c72965aaf70c8241070ddcb",
+    "files": {
+      "Jev-Style-0.8B-Decision-v3-F16.gguf": {
+        "general.name": {
+          "source": "Text Only",
+          "staged": "Jev-Style-0.8B-Decision-v3"
+        },
+        "source_file_sha256": "7d75f4925716ca94e1da3e73c239ecbe58fc712fa07c153b3550f59b626aa0e6",
+        "source_file_bytes": 1516744128,
+        "staged_file_bytes": 1516744160,
+        "tensor_count": 320,
+        "tensor_data_sha256": "7975b3b7cc4ae95d3a2b651b760ccf8c86ac78b81643c6cea150e1d0bcec231a",
+        "tensor_data_offset": {
+          "source": 10961088,
+          "staged": 10961120
+        },
+        "checks": {
+          "general_name": true,
+          "other_kv_identical": true,
+          "tensor_table_identical": true,
+          "tensor_data_identical": true,
+          "source_inode_distinct": true
+        }
+      },
+      "Jev-Style-0.8B-Decision-v3-Q8_0.gguf": {
+        "general.name": {
+          "source": "Text Only",
+          "staged": "Jev-Style-0.8B-Decision-v3"
+        },
+        "source_file_sha256": "70b3f1fe71bc560374ed4054898da80f0227c40ad12e9edda4c9a2e5c5912a05",
+        "source_file_bytes": 811843008,
+        "staged_file_bytes": 811843040,
+        "tensor_count": 320,
+        "tensor_data_sha256": "3f268d647972c13945e05d6c2449d7ad0bcb29ca78fcd546e20eaad92b10e3fe",
+        "tensor_data_offset": {
+          "source": 10961088,
+          "staged": 10961120
+        },
+        "checks": {
+          "general_name": true,
+          "other_kv_identical": true,
+          "tensor_table_identical": true,
+          "tensor_data_identical": true,
+          "source_inode_distinct": true
+        }
+      },
+      "Jev-Style-0.8B-Decision-v3-Q4_K_M.gguf": {
+        "general.name": {
+          "source": "Text Only",
+          "staged": "Jev-Style-0.8B-Decision-v3"
+        },
+        "source_file_sha256": "c5d76500d861ad1127eb1ae4e5d43e59c61a5babf4a845b316b7c82f78ef9396",
+        "source_file_bytes": 529296832,
+        "staged_file_bytes": 529296864,
+        "tensor_count": 320,
+        "tensor_data_sha256": "ecc2589e70d943e6c5111db0957af786538675fff27e807d548233b0ccb93101",
+        "tensor_data_offset": {
+          "source": 10961088,
+          "staged": 10961120
+        },
+        "checks": {
+          "general_name": true,
+          "other_kv_identical": true,
+          "tensor_table_identical": true,
+          "tensor_data_identical": true,
+          "source_inode_distinct": true
+        }
+      }
+    }
+  },
+  "runtime_parity": {
+    "protocol": "2026-09-24: each runtime script run in a clean subprocess (cwd = repo folder, empty PYTHONPATH, HF_HUB_OFFLINE=1, --verify) on 24 fixed parity-fixture rows (every 10th of the 240 G5 rows; 12 categories families, choice/score/noul, 92-8156 tokens) and compared with the reference (training-code) scorer of the same format on the same inputs, probabilities with the same calibration temperature; plus 2 synthetic long states (16,381 and 25,582 tokens). Rendered token ids identical to the reference renderer on 244/244 rows (240 fixture rows + 4 adversarial special-token/unicode rows). Re-run 2026-09-24 after the rename to Jev-Style-0.8B-Decision-v3, the no-category = global-temperature default and the GGUF general.name metadata edit: all six formats again identical to the reference scorer run on the original (pre-edit) files (max |prob diff| 0.0 same backend, 0 top-1 changes). Re-run 2026-09-25 after the GGUF decide_many fix (runtime code change in decide_many only, docstrings in all scripts): all six formats gave outputs identical (0.0) to the 2026-09-24 run on the 24 rows.",
+    "results": {
+      "F16": {
+        "rows": 24,
+        "errors": 0,
+        "vs_reference_same_backend": {
+          "max_abs_prob_diff": 0.0,
+          "max_abs_score_diff": 0.0,
+          "top1_changes": 0,
+          "top1_agreement": 1.0
+        },
+        "vs_reference_torch_fp32": {
+          "max_abs_prob_diff": 0.00021979985324915852,
+          "max_abs_score_diff": 0.0029196739196777344,
+          "top1_changes": 0,
+          "top1_agreement": 1.0
+        }
+      },
+      "Q8_0": {
+        "rows": 24,
+        "errors": 0,
+        "vs_reference_same_backend": {
+          "max_abs_prob_diff": 0.0,
+          "max_abs_score_diff": 0.0,
+          "top1_changes": 0,
+          "top1_agreement": 1.0
+        },
+        "vs_reference_torch_fp32": {
+          "max_abs_prob_diff": 0.002699855778938831,
+          "max_abs_score_diff": 0.03364121913909912,
+          "top1_changes": 0,
+          "top1_agreement": 1.0
+        }
+      },
+      "Q4_K_M": {
+        "rows": 24,
+        "errors": 0,
+        "vs_reference_same_backend": {
+          "max_abs_prob_diff": 0.0,
+          "max_abs_score_diff": 0.0,
+          "top1_changes": 0,
+          "top1_agreement": 1.0
+        },
+        "vs_reference_torch_fp32": {
+          "max_abs_prob_diff": 0.03184545218113055,
+          "max_abs_score_diff": 0.30671894550323486,
+          "top1_changes": 0,
+          "top1_agreement": 1.0
+        }
+      },
+      "F16-long": {
+        "long16384:gguf": {
+          "tokens": 16381,
+          "max_abs_score_diff_vs_macjev": 0.0,
+          "top1_same": true
+        },
+        "long25600:gguf": {
+          "tokens": 25582,
+          "max_abs_score_diff_vs_macjev": 0.0,
+          "top1_same": true
+        }
+      },
+      "render_token_identity": {
+        "rows": 244,
+        "identical": 244,
+        "different": 0,
+        "bad": []
+      },
+      "decide_many": {
+        "protocol": "2026-09-25 re-run after a fix: decide_many vs decide() per question, both many_modes. many_mode='exact' (default) shares only whole 1,024-token ubatches of the state (floor(state_tokens/1024)*1024 tokens decoded once; the rest of the state plus each question decoded on a copy, split exactly as decide() splits it; states < 1,024 tokens share nothing but still go in one request). The earlier rule (share the whole state when every ubatch piece is >= 32 tokens) differed from decide() by up to 1.3e-3 in score / 8.2e-5 in probability when a long question head (12 described options, 40 options) crossed a ubatch boundary; it was replaced. many_mode='batched' = whole state once, all questions in one decode (jev-score batched mode). Test set: 5 fixture states (14-612 state tokens) x 5 questions (incl. a 12-option described head) + 44 synthetic states (5-8,200 state tokens, incl. 1,023/1,024/1,025, 2,047/2,048/2,049, 3,072 and the previously failing 500/600/700/1,700/2,600) x 4 questions (short noul, 12 described options, 40 options, 4-level score; heads up to 575 tokens); plus a reordered 2-question subset per state.",
+        "pairs_per_quant": 201,
+        "exact": {
+          "F16": {
+            "pairs": 201,
+            "max_abs_prob_diff": 0.0,
+            "max_abs_score_diff": 0.0,
+            "answer_changes": 0,
+            "pairs_with_nonzero_diff": 0,
+            "subset_reorder_max_abs_score_diff": 0.0
+          },
+          "Q8_0": {
+            "pairs": 201,
+            "max_abs_prob_diff": 0.0,
+            "max_abs_score_diff": 0.0,
+            "answer_changes": 0,
+            "pairs_with_nonzero_diff": 0,
+            "subset_reorder_max_abs_score_diff": 0.0
+          },
+          "Q4_K_M": {
+            "pairs": 201,
+            "max_abs_prob_diff": 0.0,
+            "max_abs_score_diff": 0.0,
+            "answer_changes": 0,
+            "pairs_with_nonzero_diff": 0,
+            "subset_reorder_max_abs_score_diff": 0.0
+          },
+          "gate": "bit-identical to decide(): max |prob diff| == 0.0 and 0 answer changes",
+          "gate_pass": true,
+          "independent_recheck": "independent second test script (32 synthetic states, 5-7,000 state tokens x 4 questions + a reordered subset per state): F16 128 pairs and Q4_K_M 128 pairs, max diff 0.0, 0 answer changes"
+        },
+        "batched": {
+          "F16": {
+            "pairs": 201,
+            "max_abs_prob_diff": 0.00044065521011987796,
+            "max_abs_score_diff": 0.0031585693359375,
+            "answer_changes": 1,
+            "pairs_with_nonzero_diff": 190,
+            "subset_reorder_max_abs_score_diff": 0.0022974014282226562
+          },
+          "Q8_0": {
+            "pairs": 201,
+            "max_abs_prob_diff": 0.0004022755000451794,
+            "max_abs_score_diff": 0.003612518310546875,
+            "answer_changes": 1,
+            "pairs_with_nonzero_diff": 188,
+            "subset_reorder_max_abs_score_diff": 0.001926422119140625
+          },
+          "Q4_K_M": {
+            "pairs": 201,
+            "max_abs_prob_diff": 0.001676735283422881,
+            "max_abs_score_diff": 0.012386322021484375,
+            "answer_changes": 0,
+            "pairs_with_nonzero_diff": 165,
+            "subset_reorder_max_abs_score_diff": 0.012037277221679688
+          },
+          "note": "opt-in (many_mode='batched'); not bit-identical, report only"
+        },
+        "timing_f16_informational": {
+          "protocol": "GGUF F16, states and questions of the latency chart (2026-09-23 inputs), warm, jev-score memory reset before every timed call (no prefix reuse), median of 5; Apple M1 Max 64 GB, Metal",
+          "cells": [
+            {
+              "cell": "1024x5",
+              "state_tokens": 985,
+              "exact_shared_tokens": 0,
+              "loop_ms": 1382.4,
+              "exact_ms": 1324.3,
+              "batched_ms": 365.1,
+              "exact_speedup_vs_loop": 1.04,
+              "batched_speedup_vs_loop": 3.79,
+              "exact_max_abs_prob_diff": 0.0,
+              "batched_max_abs_prob_diff": 0.00015860293574876394
+            },
+            {
+              "cell": "1024x10",
+              "state_tokens": 985,
+              "exact_shared_tokens": 0,
+              "loop_ms": 2752.3,
+              "exact_ms": 2614.5,
+              "batched_ms": 489.0,
+              "exact_speedup_vs_loop": 1.05,
+              "batched_speedup_vs_loop": 5.63,
+              "exact_max_abs_prob_diff": 0.0,
+              "batched_max_abs_prob_diff": 0.0003301056018537585
+            },
+            {
+              "cell": "4096x5",
+              "state_tokens": 4055,
+              "exact_shared_tokens": 3072,
+              "loop_ms": 5313.1,
+              "exact_ms": 2257.2,
+              "batched_ms": 1198.3,
+              "exact_speedup_vs_loop": 2.35,
+              "batched_speedup_vs_loop": 4.43,
+              "exact_max_abs_prob_diff": 0.0,
+              "batched_max_abs_prob_diff": 0.00023034970614133066
+            },
+            {
+              "cell": "4096x10",
+              "state_tokens": 4055,
+              "exact_shared_tokens": 3072,
+              "loop_ms": 10648.8,
+              "exact_ms": 3701.4,
+              "batched_ms": 1350.7,
+              "exact_speedup_vs_loop": 2.88,
+              "batched_speedup_vs_loop": 7.88,
+              "exact_max_abs_prob_diff": 0.0,
+              "batched_max_abs_prob_diff": 0.00014278970038722472
+            },
+            {
+              "cell": "8192x5",
+              "state_tokens": 8093,
+              "exact_shared_tokens": 7168,
+              "loop_ms": 11328.1,
+              "exact_ms": 3562.6,
+              "batched_ms": 2431.5,
+              "exact_speedup_vs_loop": 3.18,
+              "batched_speedup_vs_loop": 4.66,
+              "exact_max_abs_prob_diff": 0.0,
+              "batched_max_abs_prob_diff": 0.00021432728430226256
+            },
+            {
+              "cell": "8192x10",
+              "state_tokens": 8093,
+              "exact_shared_tokens": 7168,
+              "loop_ms": 22612.8,
+              "exact_ms": 5269.7,
+              "batched_ms": 2668.4,
+              "exact_speedup_vs_loop": 4.29,
+              "batched_speedup_vs_loop": 8.47,
+              "exact_max_abs_prob_diff": 0.0,
+              "batched_max_abs_prob_diff": 0.0003231294396546236
+            }
+          ]
+        }
+      }
+    }
+  }
+}

requirements.txt

@@ -0,0 +1,4 @@
+# tested with: python 3.12, tokenizers 0.23.2, numpy 2.5.3, llama.cpp 441df11f65ea0b6d0c72965aaf70c8241070ddcb
+# plus the jev-score binary: sh build_jev_score.sh /path/to/llama.cpp
+tokenizers>=0.21
+numpy

tokenizer/tokenizer.json

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

tokenizer/tokenizer_config.json

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