diff --git a/convert/ollaya_convert/catalog.py b/convert/ollaya_convert/catalog.py
index 6b3b77ef..61381a54 100644
--- a/convert/ollaya_convert/catalog.py
+++ b/convert/ollaya_convert/catalog.py
@@ -53,9 +53,10 @@ def _laya(sub, description, params, ctx, languages, mlx=False, repo=LAYA_REPO, c
     }
 
 
-def _gguf(export, repo, commit, gguf, description, params, languages, notice=None):
+def _gguf(export, repo, commit, gguf, description, params, languages, notice=None, tokenizer=None):
     """A GGUF model run by llama.cpp: the author's GGUF, unmodified, plus the decision.json and
-    calibration.json that `llm_common/export_llama.py` derived from it (`out/<export>`)."""
+    calibration.json that `llm_common/export_llama.py` derived from it (`out/<export>`). `tokenizer`: the
+    author's tokenizer.json in `repo`, for a layout that renders with it instead of the GGUF's vocabulary."""
     return {
         "kind": "gguf",
         "repo": repo,
@@ -66,6 +67,7 @@ def _gguf(export, repo, commit, gguf, description, params, languages, notice=Non
         "languages": languages,
         "description": description,
         "notice": notice,
+        "tokenizer": tokenizer,
     }
 
 
@@ -1069,6 +1071,44 @@ def _kev_license(repo, base):
                   "CUDA (RTX 4090): 593 questions, every decision the same, option logits within 7.7e-6 and "
                   "probabilities within 1.6e-6. The prompts are byte-identical to the author's jevk5.prompt.",
     },
+    "jev-style": {
+        "namespace": "library",
+        "model": "jev-style",
+        "family": "jev-style",
+        "author": "chaoliangUNSW",
+        "license": "Apache-2.0",
+        "license_text": "Jev-Style by chaoliangUNSW (https://huggingface.co/chaoliangUNSW), a fine-tune of "
+                        "Qwen3.5-2B by the Qwen team (Apache-2.0). Its render v2 input and verdict readout "
+                        "are the author's.\n"
+                        "Licensed under the Apache License, Version 2.0.\n\n" + LICENSE_APACHE,
+        "tags": {
+            # Jev-Style-2B-Decision-v3. The GGUF holds the weights and the readout tokens (' yes' 9542,
+            # ' no' 874, ' ->' 1411); the render uses the author's tokenizer.json, which the runtime the
+            # author measured uses (llama.cpp's own pre-tokenizer splits some scripts, e.g. Devanagari and
+            # Arabic, differently). Q8_0 is the default: the card puts Q4_K_M at 95.7 % top-1 agreement with
+            # fp32 and calls it noisier on long inputs.
+            "2b": _gguf("jev-style-2b-q8_0", "chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF",
+                        "283b9eb7903aeb184b16d49ab8f38b256f4afcb3",
+                        "Jev-Style-2B-Decision-v3-Q8_0.gguf",
+                        "Jev-Style-2B-Decision-v3 (Qwen3.5-2B fine-tune), Q8_0 GGUF on llama.cpp: a "
+                        "non-causal block-attention decision model, the verdict readout logit(' yes') - "
+                        "logit(' no') at each option's ' ->' slot, with the author's global temperature 0.828. "
+                        "No option cap; up to 25,600 input tokens.",
+                        "2B", ["en"], tokenizer="tokenizer/tokenizer.json"),
+            "2b-q4_k_m": _gguf("jev-style-2b-q4_k_m", "chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF",
+                               "283b9eb7903aeb184b16d49ab8f38b256f4afcb3",
+                               "Jev-Style-2B-Decision-v3-Q4_K_M.gguf",
+                               "Jev-Style-2B-Decision-v3, Q4_K_M GGUF (1.3 GB): the smaller download, 95.7 % "
+                               "top-1 agreement with fp32 by the author's measurement and noisier on long inputs.",
+                               "2B", ["en"], tokenizer="tokenizer/tokenizer.json"),
+        },
+        "aliases": {"latest": "2b"},
+        "parity": "Ollaya's runner matches the author's own jev-score-v2 (unchanged, on the pinned llama.cpp build "
+                  "b11146) on the same GGUF and device: 582 questions per file, identical token ids, verdict slots "
+                  "and attention blocks, every decision the same and verdict scores within 4.4e-16 (Q8_0 and "
+                  "Q4_K_M; x86-64 CPU on a community machine, and CUDA on an RTX 5090). The render is identical "
+                  "to the author's jev_style_decision_gguf.py on the author's tokenizer.",
+    },
     "decima": {
         "namespace": "library",
         "model": "decima",
diff --git a/convert/ollaya_convert/families/jev_style/__init__.py b/convert/ollaya_convert/families/jev_style/__init__.py
new file mode 100644
index 00000000..a3af0348
--- /dev/null
+++ b/convert/ollaya_convert/families/jev_style/__init__.py
@@ -0,0 +1 @@
+"""Jev-Style (chaoliangUNSW/Jev-Style-2B-Decision-v3, GGUF) on Ollaya's llama.cpp runner."""
diff --git a/convert/ollaya_convert/families/jev_style/goldens.py b/convert/ollaya_convert/families/jev_style/goldens.py
new file mode 100644
index 00000000..e4ec0225
--- /dev/null
+++ b/convert/ollaya_convert/families/jev_style/goldens.py
@@ -0,0 +1,243 @@
+"""Goldens for `jev-style-v1` from the author's own runtime: the render of `jev_style_decision_gguf.py` (its
+`Renderer` on the pinned `tokenizer/tokenizer.json`) and the scores of `jev-score-v2` (`jev_score_v2.cpp`,
+unchanged, built against the llama.cpp build Ollaya ships, b11146). ADR 0003: a `seq_cp` split needs its own
+reference, and this is it.
+
+    python -m ollaya_convert.families.jev_style.goldens out/jev-style-2b-q8_0 \
+        --upstream <the GGUF repo at the pinned commit> --scorer <build>/jev-score-v2 \
+        --gguf <Jev-Style-2B-Decision-v3-Q8_0.gguf> --requests ollaya-shared-requests.jsonl [--device cpu|CUDA0]
+
+Build the scorer with the author's `build_jev_score.sh` against a b11146 checkout, or compile it against the
+b11146 headers and link the stock release libraries (`scripts/llama-cpp.sh linux-amd64`): the same libllama
+the runner loads. Needs the author's pinned `tokenizers` (requirements.txt) and numpy.
+
+The requests are Ollaya's shared set (the wire form, as an HTTP client sends it) plus this layout's own cases:
+a state of several attention blocks, a catalogue overflow of 150 options (several catalogue blocks), an input of
+exactly 25,600 tokens and one of 25,601 (rejected).
+
+A wire question becomes the author's `{"t", "ins", "crit"}` with Ollaya's request semantics (laya's), which the
+author's `make_question` shares: a choice given as a list of labels is `{label: None}` (duplicates collapse onto
+their first position), and noul keys are lower-cased (the last spelling wins). Everything else, including the
+author's limits (2..10 score levels, a non-empty string instruction), is the author's code.
+
+Writes <export dir>/goldens-<device>.jsonl, one line per request:
+    {"id", "state", "questions", "error": "invalid", "message"}          the author's runtime rejects it
+    {"id", "state", "questions", "state_tokens",
+     "rows": [{"qid", "names", "ids", "slots", "blocks", "catalogue_overflow",
+               "logits": [[yes, no], ...], "scores": [...], "probabilities": [...]}]}
+A rejected request is followed by "<id>#valid" with the questions the author's runtime accepts on their own.
+Every accepted render is also checked against this family's `ref.py` before it is written.
+"""
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import os
+import subprocess
+import sys
+import time
+
+import numpy as np
+
+from . import ref
+
+OUT = os.path.join(os.path.dirname(__file__), "..", "..", "..", "out")
+
+
+def load_upstream(path):
+    spec = importlib.util.spec_from_file_location("jev_style_decision_gguf",
+                                                  os.path.join(path, "jev_style_decision_gguf.py"))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def author_question(q):
+    """A wire question as the author's {"t", "ins", "crit"}, with Ollaya's (laya's) request semantics."""
+    if not isinstance(q, dict):
+        return q
+    t, crit = q.get("type"), q.get("criteria")
+    if t == "choice" and isinstance(crit, list) and crit and all(isinstance(c, str) for c in crit):
+        crit = dict.fromkeys(crit)
+    elif t == "noul" and isinstance(crit, dict):
+        crit = {str(k).lower(): v for k, v in crit.items()}
+    return {"t": t, "ins": q.get("instructions"), "crit": crit}
+
+
+def device_class(device):
+    return "cpu" if device == "cpu" else "cuda" if device.lower().startswith("cuda") else device.lower()
+
+
+class Scorer:
+    """The author's jev-score-v2, a JSON-lines server on stdin/stdout."""
+
+    def __init__(self, binary, gguf, device, threads):
+        args = [binary, "--model", gguf, "--ngl", "0" if device == "cpu" else "999", "--threads", str(threads)]
+        self.p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True, bufsize=1)
+        self.info = json.loads(self.p.stdout.readline())
+        if not self.info.get("ready"):
+            raise SystemExit("jev-score-v2 did not start: %s" % self.info)
+
+    def ask(self, req):
+        self.p.stdin.write(json.dumps(req) + "\n")
+        self.p.stdin.flush()
+        resp = json.loads(self.p.stdout.readline())
+        if "error" in resp:
+            raise RuntimeError("jev-score-v2: %s" % resp["error"])
+        return resp
+
+    def close(self):
+        try:
+            self.p.stdin.write(json.dumps({"cmd": "quit"}) + "\n")
+            self.p.stdin.flush()
+        except BrokenPipeError:
+            pass
+        self.p.wait(timeout=60)
+
+
+def softmax(scores, t):
+    z = np.asarray(scores, dtype=np.float64) / t
+    e = np.exp(z - z.max())
+    return (e / e.sum()).tolist()
+
+
+def layout_cases(renderer):
+    """This layout's own requests: several state blocks, catalogue overflow, the 25,600-token edge."""
+    noul = {"type": "noul", "instructions": "Did the deploy cause the checkout failures?"}
+    sentence = ("The customer reports intermittent failures on the checkout page after the latest deploy; "
+                "payments time out, carts empty themselves and the support queue keeps growing. ")
+    out = [("jev/multi_block_state", sentence * 220, {
+        "caused": noul,
+        "team": {"type": "choice", "instructions": "Which team should take it?",
+                 "criteria": {"payments": "card processing and refunds", "web": "the checkout front end",
+                              "infra": None}},
+        "severity": {"type": "score", "instructions": "How severe is it?",
+                     "criteria": ["minor", "degraded", "major", "outage"]}})]
+    options = {"intent_%03d" % i: "the customer asks about item %d of the catalogue: billing, shipping, returns, "
+               "warranty or account changes for that item" % i for i in range(150)}
+    out.append(("jev/overflow_150", "I want to return the blender I bought last week and get my money back.",
+                {"intent": {"type": "choice", "instructions": "Which intent matches the message?",
+                            "criteria": options}}))
+    # Digits are one token each in this tokenizer (and never merge), so the state can hit an exact length.
+    q = author_question(noul)
+    for want in (ref.CONTEXT_LIMIT, ref.CONTEXT_LIMIT + 1):
+        m = 0
+        for _ in range(8):
+            state = "Ticket log follows. " + "7" * m
+            p = renderer.pieces(state, q)
+            n = len(p["prefix"]) + len(p["head"]) + sum(len(renderer.dash) + len(o) + 1 + len(renderer.newline)
+                                                        for o in p["opts"])  # the short form's length
+            if n == want:
+                break
+            m += want - n
+        else:
+            raise SystemExit("could not build a %d-token input" % want)
+        out.append(("jev/budget_%d" % want, state, {"q": noul}))
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("export_dir", help="out/jev-style-<slug>, with the decision.json export_llama wrote")
+    ap.add_argument("--upstream", required=True, help="the GGUF repo at the pinned commit (jev_style_decision_gguf.py, "
+                                                      "readout_config.json, tokenizer/tokenizer.json)")
+    ap.add_argument("--scorer", required=True, help="jev-score-v2 built against llama.cpp b11146")
+    ap.add_argument("--gguf", required=True)
+    ap.add_argument("--requests", required=True, help="Ollaya's shared request set (JSON lines)")
+    ap.add_argument("--device", default="cpu", help="cpu, or CUDA0 (all layers offloaded)")
+    ap.add_argument("--threads", type=int, default=8)
+    a = ap.parse_args()
+
+    up = load_upstream(a.upstream)
+    readout = json.load(open(os.path.join(a.upstream, "readout_config.json"), encoding="utf-8"))
+    enc = up.TextEncoder(os.path.join(a.upstream, "tokenizer", "tokenizer.json"))
+    renderer = up.Renderer(enc, readout)
+    temperature = float(readout["temperatures"]["global"])
+    decision = json.load(open(os.path.join(a.export_dir, "decision.json"), encoding="utf-8"))
+    yes, no, arrow = decision["yes"], decision["no"], decision["arrow"]
+    assert (yes, no, arrow) == (renderer.yes, renderer.no, renderer.arrow[0]), "readout ids differ from decision.json"
+
+    cases = [(r["id"], r["state"], r["questions"]) for r in map(json.loads, open(a.requests, encoding="utf-8"))
+             if r.get("id")]
+    cases += layout_cases(renderer)
+
+    scorer = Scorer(a.scorer, a.gguf, a.device, a.threads)
+    name = "goldens-%s" % device_class(a.device)
+    with open(os.path.join(a.export_dir, name + ".meta.json"), "w", encoding="utf-8") as f:
+        json.dump({"reference": "jev_style_decision_gguf.py Renderer + jev-score-v2 (jev_score_v2.cpp, unchanged)",
+                   "scorer": {k: scorer.info.get(k) for k in ("protocol", "flash_attn", "gpu_offload", "n_ctx",
+                                                              "n_ubatch", "n_seq_max", "n_outputs_max", "cache_type",
+                                                              "n_threads", "desc", "system_info")},
+                   "device": a.device, "gguf": os.path.basename(a.gguf), "temperature": temperature,
+                   "requests": os.path.basename(a.requests)}, f, indent=1)
+
+    def render_all(state, questions):
+        """The author's render of every question (all before any scoring, as score_many), checked against ref.py."""
+        if not isinstance(questions, dict) or not questions:
+            raise up.QuestionError("questions must be a non-empty object")
+        prefix = renderer.prefix_ids(state)
+        out = []
+        for qid, q in questions.items():
+            r = renderer.render(state, up.make_question(author_question(q)), prefix=prefix)
+            mine = ref.render(state, q, enc, arrow, prefix=prefix)
+            assert (mine.ids, mine.slots, mine.blocks, mine.names) == (r.ids, r.slots, [tuple(b) for b in r.blocks],
+                                                                        r.names), "ref.py differs on %s" % qid
+            out.append((qid, r))
+        return prefix, out
+
+    def record(cid, state, questions):
+        prefix, rendered = render_all(state, questions)
+        p = len(prefix)
+        resp = scorer.ask({"prefix": prefix, "prefix_blocks": rendered[0][1].state_blocks,
+                           "questions": [{"ids": r.ids[p:], "blocks": r.question_blocks, "slots": r.slots,
+                                          "rows": [yes, no]} for _, r in rendered],
+                           "keep_prefix": False, "return_logits": True})
+        rows = []
+        for (qid, r), res in zip(rendered, resp["results"]):
+            if not res["finite"]:
+                raise RuntimeError("%s/%s: non-finite score from jev-score-v2" % (cid, qid))
+            rows.append({"qid": qid, "names": r.names, "ids": r.ids, "slots": r.slots,
+                         "blocks": [list(b) for b in r.blocks], "catalogue_overflow": r.catalogue_overflow,
+                         "logits": res["logits"], "scores": res["scores"],
+                         "probabilities": softmax(res["scores"], temperature)})
+        return {"id": cid, "state": state, "questions": questions, "state_tokens": p, "rows": rows}
+
+    n, t0 = 0, time.time()
+    try:
+        with open(os.path.join(a.export_dir, name + ".jsonl"), "w", encoding="utf-8") as f:
+            for cid, state, questions in cases:
+                try:
+                    rec = record(cid, state, questions)
+                except (up.QuestionError, up.InputBudgetError) as e:
+                    for qid, q in (questions.items() if isinstance(questions, dict) else []):
+                        try:  # the port must reject what the author's runtime rejects
+                            ref.render(state, q, enc, arrow)
+                        except (ref.QuestionError, ref.InputBudgetError):
+                            break
+                    else:
+                        raise AssertionError("%s: the author's runtime rejects it (%s), ref.py accepts" % (cid, e))
+                    f.write(json.dumps({"id": cid, "state": state, "questions": questions, "error": "invalid",
+                                        "message": str(e)}, ensure_ascii=False) + "\n")
+                    valid = {}
+                    for qid, q in (questions.items() if isinstance(questions, dict) else []):
+                        try:
+                            render_all(state, {qid: q})
+                            valid[qid] = q
+                        except (up.QuestionError, up.InputBudgetError):
+                            pass
+                    if not valid:
+                        continue
+                    cid, rec = cid + "#valid", record(cid + "#valid", state, valid)
+                f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                f.flush()
+                n += 1
+                print("%4d %-48s %6d tokens %6.0fs" % (n, cid, max(len(r["ids"]) for r in rec["rows"]),
+                                                       time.time() - t0), flush=True)
+    finally:
+        scorer.close()
+    print("wrote %d scored requests to %s" % (n, os.path.join(a.export_dir, name + ".jsonl")))
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/convert/ollaya_convert/families/jev_style/load_backends.c b/convert/ollaya_convert/families/jev_style/load_backends.c
new file mode 100644
index 00000000..3d266862
--- /dev/null
+++ b/convert/ollaya_convert/families/jev_style/load_backends.c
@@ -0,0 +1,20 @@
+/* Linked next to the author's jev_score_v2.cpp (unchanged) when it is built against ggml-org's stock release
+ * libraries of llama.cpp b11146, the ones the runner loads. Those builds load the CPU backend variants at run
+ * time (GGML_BACKEND_DL), and jev-score-v2 calls only llama_backend_init(), so the backends are loaded here,
+ * before main(), from the directory that holds the libraries (JEV_GGML_BACKEND_DIR).
+ *
+ *   c++ -std=c++17 -O2 -I<b11146>/include -I<b11146>/ggml/include -I<b11146>/vendor \
+ *       jev_score_v2.cpp -x c load_backends.c -o jev-score-v2 -L<libs> -lllama -lggml -lggml-base -Wl,-rpath,<libs>
+ */
+#include <stdlib.h>
+
+#include "ggml-backend.h"
+
+__attribute__((constructor)) static void jev_load_backends(void) {
+    const char * dir = getenv("JEV_GGML_BACKEND_DIR");
+    if (dir && *dir) {
+        ggml_backend_load_all_from_path(dir);
+    } else {
+        ggml_backend_load_all();
+    }
+}
diff --git a/convert/ollaya_convert/families/jev_style/ref.py b/convert/ollaya_convert/families/jev_style/ref.py
new file mode 100644
index 00000000..c9079583
--- /dev/null
+++ b/convert/ollaya_convert/families/jev_style/ref.py
@@ -0,0 +1,149 @@
+"""Reference implementation of `jev-style-v1`: chaoliangUNSW/Jev-Style-2B-Decision-v3's render v2
+(`macjev-render-v2-long-options`, layout `sb`) and verdict readout, ported from the model's own
+self-contained runtime `jev_style_decision_gguf.py` (the "Shared core", Apache-2.0).
+
+Input layout (token segments are encoded separately so the ` ->` slots are exact):
+
+    state prefix   State:\n<state>\n\n
+    short form     Question [<type>]: <question>\nOptions:\n
+    (q+opts+slots   - <option 1> ->\n ... - <option K> ->\n
+     <= 2048 tok)
+    overflow form  Question [<type>]: <question>\nOptions:\n
+    (otherwise)    Option 1: <option 1>\n ... Option K: <option K>\n            (the catalogue)
+                   Judge each numbered option in the complete catalogue above:\n
+                   Option 1 ->\n ... Option K ->\n                               (the rubric)
+
+Score of option k = logit(" yes") - logit(" no") at its ` ->` slot; probabilities are
+softmax(scores / T) in canonical option order, one global temperature. Everything is tokenised with
+no BOS/EOS and special tokens split (never control tokens).
+"""
+from __future__ import annotations
+
+import json
+
+LAYOUT = "jev-style-v1"
+TEMPLATE_VERSION = "macjev-render-v2-long-options"
+BLOCK = 2048
+CONTEXT_LIMIT = 25_600
+UPSTREAM = {
+    "runtime": "https://huggingface.co/chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF",
+    "source": "jev_style_decision_gguf.py",
+}
+
+
+class QuestionError(ValueError):
+    """A question the layout rejects (HTTP 400)."""
+
+
+class InputBudgetError(ValueError):
+    """The rendered input exceeds the token budget (HTTP 422). Nothing was truncated."""
+
+
+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 with type/instructions/criteria")
+    t, crit = question.get("type"), question.get("criteria")
+    ins = question.get("instructions")
+    if not isinstance(ins, str) or not ins.strip():
+        raise QuestionError("question text (instructions) must be a non-empty string")
+    if t == "choice":
+        if isinstance(crit, list) and crit and all(isinstance(c, str) for c in crit):
+            return list(dict.fromkeys(crit))  # a list of labels -> {label: None}; dupes collapse
+        if not isinstance(crit, dict) or not crit:
+            raise QuestionError("choice needs a non-empty object {option name: description or null} "
+                                "or a list of labels")
+        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 null or {'false': ..., 'true': ...}")
+        return ["false", "true"]
+    raise QuestionError("unknown question type %r (expected choice, score or noul)" % (t,))
+
+
+def serialize_state(state) -> str:
+    """A string state passes through; any other JSON value is `json.dumps`ed (ensure_ascii=False)."""
+    return state if isinstance(state, str) else json.dumps(state, ensure_ascii=False)
+
+
+def _criterion(value) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False, separators=(", ", ": "), default=str)
+
+
+def render_options(question):
+    """Option bodies in canonical order (without the `- ` / ` ->` wrapping)."""
+    t, crit = question["type"], question.get("criteria")
+    if t == "choice":
+        if isinstance(crit, list):
+            return list(dict.fromkeys(str(c) for c in crit))  # labels; dupes collapse
+        return [k if v is None or v == "" else "%s: %s" % (k, _criterion(v)) for k, v in crit.items()]
+    if t == "score":
+        return ["level %d: %s" % (i, _criterion(c)) for i, c in enumerate(crit)]
+    crit = {str(k).lower(): v for k, v in crit.items()} if isinstance(crit, dict) else {}
+    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")]
+
+
+def _blocks(start, stop):
+    return [(s, min(s + BLOCK, stop)) for s in range(start, stop, BLOCK)]
+
+
+class Rendered:
+    __slots__ = ("ids", "prefix_len", "slots", "blocks", "names", "qtype", "catalogue_overflow")
+
+    def __init__(self, ids, prefix_len, slots, blocks, names, qtype, catalogue_overflow):
+        self.ids, self.prefix_len, self.slots, self.blocks = ids, prefix_len, slots, blocks
+        self.names, self.qtype, self.catalogue_overflow = names, qtype, catalogue_overflow
+
+
+def prefix_ids(state, enc):
+    """The state prefix `State:\\n<state>\\n\\n`, tokenised once and shared across a request."""
+    return enc("State:\n") + enc(serialize_state(state)) + enc("\n\n")
+
+
+def render(state, question, enc, arrow, prefix=None, max_len=CONTEXT_LIMIT):
+    """Render one question. `enc(text)` tokenises with no BOS and special tokens split; `arrow` is the
+    ` ->` token id. Returns a Rendered (ids, prefix_len, verdict slots, attention blocks)."""
+    names = option_names(question)
+    opts = [enc(o) for o in render_options(question)]
+    k = len(opts)
+    if k < 1:
+        raise QuestionError("at least one option is required")
+    prefix = prefix_ids(state, enc) if prefix is None else list(prefix)
+    head = enc("Question [%s]: %s\nOptions:\n" % (question["type"], question["instructions"]))
+    dash, newline = enc("- "), enc("\n")
+
+    short, rel = list(head), []
+    for o in opts:
+        short += dash + list(o) + [arrow]
+        rel.append(len(short) - 1)
+        short += newline
+    overflow = len(short) > BLOCK
+    if not overflow:
+        ids = prefix + short
+        slots = [len(prefix) + s for s in rel]
+        blocks = _blocks(0, len(prefix)) + [(len(prefix), len(ids))]
+    else:
+        catalogue = list(head)
+        for pos, o in enumerate(opts):
+            catalogue += enc("Option %d: " % (pos + 1)) + list(o) + newline
+        doc_end = len(prefix) + len(catalogue)
+        rubric, rel = enc("Judge each numbered option in the complete catalogue above:\n"), []
+        for pos in range(k):
+            rubric += enc("Option %d" % (pos + 1)) + [arrow]
+            rel.append(len(rubric) - 1)
+            rubric += newline
+        ids = prefix + catalogue + rubric
+        slots = [doc_end + s for s in rel]
+        blocks = _blocks(0, len(prefix)) + _blocks(len(prefix), doc_end) + _blocks(doc_end, len(ids))
+    if len(ids) > max_len:
+        raise InputBudgetError("the complete input needs %d tokens; the limit is %d. Nothing was "
+                               "truncated." % (len(ids), max_len))
+    return Rendered(ids, len(prefix), slots, blocks, names, question["type"], overflow)
diff --git a/convert/ollaya_convert/families/llm_common/export_llama.py b/convert/ollaya_convert/families/llm_common/export_llama.py
index a2c3d27d..7aa961b5 100644
--- a/convert/ollaya_convert/families/llm_common/export_llama.py
+++ b/convert/ollaya_convert/families/llm_common/export_llama.py
@@ -362,6 +362,37 @@ def winnow_error_class(state, questions, labels, template):
     return "invalid"
 
 
+class JevStyle:
+    """jev-style-v1: chaoliangUNSW/Jev-Style-2B-Decision-v3's render v2 and verdict readout
+    (logit(" yes") - logit(" no") at each option's " ->" slot) under non-causal block attention. The
+    decode and readout live in the Rust runner (run_jev_style); the package here is the GGUF pin, the
+    three readout token ids and the one global temperature. One cold pass per question."""
+
+    def __init__(self, srv, a):
+        from ..jev_style import ref
+        self.ref = ref
+        self.srv = srv
+        self.n_ctx = a.n_ctx
+        ids = {}
+        for text in (" yes", " no", " ->"):
+            tok = srv.tokenize(text, add_special=False, parse_special=False)
+            if len(tok) != 1 or srv.pieces(tok)[0] != text:
+                raise SystemExit("readout token %r is not one token in this GGUF: %s" % (text, tok))
+            ids[text] = tok[0]
+        self.decision = {
+            "family": "jev-style", "layout": ref.LAYOUT,
+            "yes": ids[" yes"], "no": ids[" no"], "arrow": ids[" ->"],
+            "upstream": ref.UPSTREAM,
+        }
+        self.plan = "cold"
+        # A non-causal context, logits read at the verdict slots (see run_jev_style).
+        self.llama_extra = {"n_ctx": 32768, "attention_type": 1, "n_ubatch": 2048, "n_seq_max": 2,
+                            "n_outputs_max": 512, "kv_unified": True}
+
+    def encode(self, state, questions):
+        raise NotImplementedError("jev-style goldens: python -m ollaya_convert.families.jev_style.goldens")
+
+
 def error_class(layout, lay, state, questions, e):
     if layout == "winnow":
         return winnow_error_class(state, winnow_questions(questions), lay.labels, lay.template)
@@ -390,7 +421,7 @@ def main():
     from . import cases
 
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("layout", choices=["llm-logits", "winnow", "jevk5", "jebadiah", "cygnet"])
+    ap.add_argument("layout", choices=["llm-logits", "winnow", "jevk5", "jebadiah", "cygnet", "jev-style"])
     ap.add_argument("--server", required=True, help="the pinned llama-server build the runtime ships")
     ap.add_argument("--gguf", required=True)
     ap.add_argument("--slug", required=True)
@@ -422,7 +453,8 @@ def main():
                             log=os.path.join(out, "llama-server-%s.log" % device_class(a.device)), timeout=1800)
     try:
         props = srv.props()
-        lay = {"llm-logits": LlmLogits, "winnow": Winnow, "jevk5": JevK5, "jebadiah": Jebadiah, "cygnet": Cygnet}[a.layout](srv, a)
+        lay = {"llm-logits": LlmLogits, "winnow": Winnow, "jevk5": JevK5, "jebadiah": Jebadiah, "cygnet": Cygnet,
+               "jev-style": JevStyle}[a.layout](srv, a)
         sha = sha256_file(a.gguf)
         decision = {"engine": "llama", **lay.decision}
         decision["gguf"] = {
@@ -433,6 +465,7 @@ def main():
         }
         decision["llama"] = {"n_ctx": a.n_ctx, "swa_full": swa, "plan": getattr(lay, "plan", "prefix"),
                              "build": LLAMA_BUILD}
+        decision["llama"].update(getattr(lay, "llama_extra", {}))
         with open(os.path.join(out, "decision.json"), "w", encoding="utf-8") as f:
             json.dump(decision, f, indent=1, ensure_ascii=False)
         if a.calibration:
@@ -451,6 +484,11 @@ def main():
                    "source": a.temperature_source or "uncalibrated (temperature 1.0)"}
         with open(os.path.join(out, "calibration.json"), "w", encoding="utf-8") as f:
             json.dump(cal, f, indent=2)
+        if a.layout == "jev-style":
+            print("%s: decision.json + calibration.json written. jev-style uses a non-causal "
+                  "verdict readout: its goldens come from the author's jev-score-v2, not the causal "
+                  "llama-server plan (python -m ollaya_convert.families.jev_style.goldens)." % out)
+            return
 
         plan = FixedPlan(post_to(srv.url))
         n_rows = 0
diff --git a/convert/ollaya_convert/package.py b/convert/ollaya_convert/package.py
index 0e7655b2..0b2ba86f 100644
--- a/convert/ollaya_convert/package.py
+++ b/convert/ollaya_convert/package.py
@@ -252,6 +252,8 @@ def package_gguf(spec, tag, v, blobs):
     }, indent=2).encode())
     print("  %s:%s %s %.2f GB (%s)" % (spec["model"], tag, pin["quantization"], gguf["size"] / 1e9, v["gguf"]))
     layers = [gguf, decision, calibration, lic]
+    if v.get("tokenizer"):  # the author's tokenizer.json, for a layout that renders with it (jev-style)
+        layers.append(upstream(MEDIA["tokenizer"], repo, commit, v["tokenizer"]))
     if v.get("mmproj"):  # a path in `repo`, or `(repo, commit, path)` for the author's file elsewhere
         m = v["mmproj"]
         layers.append(upstream(MEDIA["mmproj"], *(m if isinstance(m, tuple) else (repo, commit, m))))
diff --git a/convert/ollaya_convert/parity_run.py b/convert/ollaya_convert/parity_run.py
index 81da487b..3143263f 100644
--- a/convert/ollaya_convert/parity_run.py
+++ b/convert/ollaya_convert/parity_run.py
@@ -9,8 +9,9 @@
 one file per day, machine and device; a tag checked again that day replaces its row. `bench_plan` reads these files
 to find the parity result of a changed graph.
 
-Only the examples that print a `record:` line can be recorded (the Qwen3.5 families today); add the line to an
-example when its family is next touched. A CUDA run needs the CUDA libraries on LD_LIBRARY_PATH, as any CUDA parity run.
+Only the examples that print a `record:` line can be recorded (the Qwen3.5 families today, and jev-style among the
+GGUF families: `GGUF_RECORDED`); add the line to an example when its family is next touched. A GGUF example needs
+OLLAYA_LIBRARY_PATH (an install's lib/ollaya), as when it is run directly. A CUDA run needs the CUDA libraries on LD_LIBRARY_PATH, as any CUDA parity run.
 On an RTX 50-series GPU (sm_120), which pyke's CUDA build has no kernels for, pass `--cuda-dynamic <pack dir>`: the
 example is built with `cuda-dynamic` and loads Microsoft's ONNX Runtime from a GPU pack's `cuda_v13`, as the release's
 CUDA runner does (docs/decisions/0004-cuda-onnxruntime-builds.md).
@@ -40,6 +41,9 @@
 }
 # Families that run on another family's engine, and so on its parity example.
 EXAMPLE = {"d3": "pplx", "decision2": "decision"}
+# GGUF families whose example prints a `record:` line. Their goldens are per device, in the export directory
+# (`goldens-<device>.jsonl`, from the family's goldens.py), and the export is pinned by the GGUF's sha256.
+GGUF_RECORDED = {"jev-style"}
 
 
 def wl_tags():
@@ -52,6 +56,20 @@ def wl_tags():
     return out
 
 
+def gguf_tags():
+    """tag -> (family, export directory) for every GGUF tag whose family's example can be recorded."""
+    return {"%s:%s" % (e["model"], t): (e["family"], os.path.normpath(v["export_dir"]))
+            for e in CATALOG.values() if e["family"] in GGUF_RECORDED
+            for t, v in e["tags"].items() if v.get("kind") == "gguf"}
+
+
+def gguf_command(family, d, device):
+    """The cargo command that runs a GGUF family's parity example on its goldens for `device`."""
+    example = "parity_" + family.replace("-", "_")
+    cmd = ["cargo", "run", "--release", "-q", "-p", "ollaya-runner", "--example", example]
+    return cmd + ["--", d, os.path.join(d, "goldens-%s.jsonl" % device), device], "fp32"
+
+
 def command(family, d, device, cuda_dynamic=None):
     """The cargo command that runs the parity example of export directory `d`, and its gate."""
     name = os.path.basename(d)
@@ -76,6 +94,8 @@ def parse(tag, stdout, returncode):
 
 
 def export_sha256(d):
+    if not os.path.exists(os.path.join(d, "model.onnx")):  # a GGUF export: the author's file, by its pin
+        return json.load(open(os.path.join(d, "decision.json"), encoding="utf-8"))["gguf"]["sha256"]
     with open(os.path.join(d, "model.onnx"), "rb") as f:
         return hashlib.file_digest(f, "sha256").hexdigest()
 
@@ -115,10 +135,11 @@ def main():
     if a.cuda_dynamic:
         env["ORT_DYLIB_PATH"] = os.path.join(a.cuda_dynamic, "libonnxruntime.so.1")
         env["LD_LIBRARY_PATH"] = os.pathsep.join(p for p in (a.cuda_dynamic, env.get("LD_LIBRARY_PATH")) if p)
-    known = wl_tags()
-    unknown = [t for t in a.tags if t not in known]
+    known, gguf = wl_tags(), gguf_tags()
+    unknown = [t for t in a.tags if t not in known and t not in gguf]
     if unknown:
-        sys.exit("not converted under families/ (catalog.py kind 'wl'): %s" % " ".join(unknown))
+        sys.exit("not converted under families/ (catalog.py kind 'wl') nor a recorded GGUF family (%s): %s"
+                 % (", ".join(sorted(GGUF_RECORDED)), " ".join(unknown)))
     if a.machine not in json.load(open(os.path.join(RESULTS, "machines.json"), encoding="utf-8")):
         sys.exit("%s is not in results/machines.json; add the machine first" % a.machine)
 
@@ -126,8 +147,12 @@ def main():
     path = os.path.join(RESULTS, "runs", "%s-parity-%s-%s.json" % (date, a.machine.replace("-", ""), a.device))
     failed = []
     for tag in a.tags:
-        family, d = known[tag]
-        cmd, gate = command(family, d, a.device, a.cuda_dynamic)
+        if tag in gguf:
+            family, d = gguf[tag]
+            cmd, gate = gguf_command(family, d, a.device)
+        else:
+            family, d = known[tag]
+            cmd, gate = command(family, d, a.device, a.cuda_dynamic)
         print("== %s: %s" % (tag, " ".join(cmd)), flush=True)
         p = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True, env=env)
         print("\n".join(line for line in p.stdout.splitlines() if not line.startswith("record: ")))
diff --git a/convert/tests/test_jev_style_ref.py b/convert/tests/test_jev_style_ref.py
new file mode 100644
index 00000000..5e7cf5f9
--- /dev/null
+++ b/convert/tests/test_jev_style_ref.py
@@ -0,0 +1,70 @@
+"""jev-style `ref.py` on the inputs the shared Rust parser accepts (a choice as a list of labels, noul keys in any
+case) and on the author's stricter limits (2..10 score levels, a non-empty string instruction). The cases and the
+expected texts are the ones `crates/ollaya-decision/src/jev_style.rs` tests, so the two renders stay in step. A
+character tokenizer stands in for the GGUF's; no weights needed."""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from ollaya_convert.families.jev_style import ref
+
+ARROW = 1411
+
+
+def enc(text):
+    """One id per character, except ` ->`, which is the single verdict-slot id (as in the Rust tests)."""
+    ids, i = [], 0
+    while i < len(text):
+        if text.startswith(" ->", i):
+            ids.append(ARROW)
+            i += 3
+        else:
+            ids.append(ord(text[i]))
+            i += 1
+    return ids
+
+
+def text_of(ids):
+    return "".join(" ->" if i == ARROW else chr(i) for i in ids)
+
+
+def render(question, state="s"):
+    return ref.render(state, question, enc, ARROW)
+
+
+class AcceptedInputs(unittest.TestCase):
+    def test_choice_as_a_list_of_labels(self):
+        r = render({"type": "choice", "instructions": "Which team?",
+                    "criteria": ["billing", "tech", "billing", "sales"]})
+        self.assertEqual(r.names, ["billing", "tech", "sales"])
+        self.assertTrue(text_of(r.ids).endswith(
+            "Question [choice]: Which team?\nOptions:\n- billing ->\n- tech ->\n- sales ->\n"))
+        self.assertEqual(len(r.slots), 3)
+        self.assertTrue(all(r.ids[s] == ARROW for s in r.slots))
+
+    def test_noul_keys_in_any_case(self):
+        r = render({"type": "noul", "instructions": "Finished?",
+                    "criteria": {"TRUE": "it is done", "False": "still open"}})
+        self.assertEqual(r.names, ["false", "true"])
+        self.assertTrue(text_of(r.ids).endswith("- false: still open ->\n- true: it is done ->\n"))
+
+
+class AuthorLimits(unittest.TestCase):
+    def test_score_levels_outside_two_to_ten(self):
+        for n in (1, 11):
+            with self.assertRaisesRegex(ref.QuestionError, "2..10 level descriptions"):
+                render({"type": "score", "instructions": "How bad?",
+                        "criteria": ["level %d" % i for i in range(n)]})
+        for n in (2, 10):
+            r = render({"type": "score", "instructions": "How bad?", "criteria": ["level %d" % i for i in range(n)]})
+            self.assertEqual(len(r.slots), n)
+
+    def test_non_string_or_blank_instructions(self):
+        for ins in ({"text": "ok?"}, ["ok?"], 3, "  "):
+            with self.assertRaisesRegex(ref.QuestionError, "non-empty string"):
+                render({"type": "noul", "instructions": ins})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/convert/tests/test_jev_style_render.py b/convert/tests/test_jev_style_render.py
new file mode 100644
index 00000000..d4ccf164
--- /dev/null
+++ b/convert/tests/test_jev_style_render.py
@@ -0,0 +1,110 @@
+"""jev-style render parity at the token level: `ref.py` against the author's own `Renderer`
+(`jev_style_decision_gguf.py`) with the author's tokenizer (`tokenizer/tokenizer.json`), both at the pinned commit,
+on Ollaya's shared request set and this layout's own cases (several state blocks, a 150-option catalogue overflow,
+inputs of exactly 25,600 and 25,601 tokens). Token ids, verdict slots, attention blocks and option names must be
+identical, and both must reject the same requests.
+
+The pinned files (about 20 MB) are downloaded once into the package cache (OLLAYA_CACHE, default
+~/.cache/ollaya-package); without network access the test is skipped. Needs `tokenizers` (the convert environment).
+"""
+import hashlib
+import importlib.util
+import json
+import os
+import sys
+import unittest
+import urllib.request
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+HAVE_DEPS = all(importlib.util.find_spec(m) for m in ("numpy", "tokenizers"))
+if HAVE_DEPS:  # goldens.py imports numpy; CI's packaging job has no ML dependencies
+    from ollaya_convert.families.jev_style import goldens, ref
+
+REPO = "https://huggingface.co/chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF/resolve/" \
+       "283b9eb7903aeb184b16d49ab8f38b256f4afcb3/"
+FILES = {
+    "jev_style_decision_gguf.py": (REPO + "jev_style_decision_gguf.py",
+                                   "edfed616477f0896e49e03c9b306b159903ee3d9bc5eeea2d4d30c3727c6135a"),
+    "readout_config.json": (REPO + "readout_config.json",
+                            "4af0d578c9126d4eb1a545b6e576e0a49a967243a47b8e99e3555f081fdaa1de"),
+    # readout_config.json's tokenizer_sha256.
+    "tokenizer.json": (REPO + "tokenizer/tokenizer.json",
+                       "06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523"),
+    "ollaya-shared-requests.jsonl": (
+        "https://gist.githubusercontent.com/cobanov/dffe49d26ce328aa97716c3085249fef/raw/"
+        "0844802134668f3b9daf478870419ace27968718/ollaya-shared-requests.jsonl",
+        "c95b85a281ff542556f5c2177b07d3e26b5b14eb1658ca0cc28bf5e524c09e30"),
+}
+CACHE = Path(os.environ.get("OLLAYA_CACHE") or Path(os.environ.get("XDG_CACHE_HOME") or Path.home() / ".cache")
+             / "ollaya-package") / "jev-style-283b9eb"
+
+
+def fetch(name):
+    url, sha = FILES[name]
+    path = CACHE / name
+    if not path.exists() or hashlib.sha256(path.read_bytes()).hexdigest() != sha:
+        CACHE.mkdir(parents=True, exist_ok=True)
+        with urllib.request.urlopen(url, timeout=60) as r:
+            data = r.read()
+        if hashlib.sha256(data).hexdigest() != sha:
+            raise AssertionError("%s: sha256 differs from the pin" % url)
+        path.write_bytes(data)
+    return path
+
+
+@unittest.skipUnless(HAVE_DEPS, "needs the convert environment (numpy, tokenizers)")
+class RenderParity(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        try:
+            paths = {name: fetch(name) for name in FILES}
+        except OSError as e:  # no network: nothing to compare against
+            raise unittest.SkipTest("pinned jev-style files unavailable: %s" % e)
+        spec = importlib.util.spec_from_file_location("jev_style_decision_gguf", paths["jev_style_decision_gguf.py"])
+        cls.up = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(cls.up)
+        cls.enc = cls.up.TextEncoder(paths["tokenizer.json"])
+        cls.renderer = cls.up.Renderer(cls.enc, json.loads(paths["readout_config.json"].read_text()))
+        cls.arrow = cls.renderer.arrow[0]
+        cases = [json.loads(line) for line in paths["ollaya-shared-requests.jsonl"].read_text().splitlines() if line]
+        cls.cases = [(c["id"], c["state"], c["questions"]) for c in cases] + goldens.layout_cases(cls.renderer)
+
+    def author(self, state, questions):
+        prefix = self.renderer.prefix_ids(state)
+        return [(qid, self.renderer.render(state, self.up.make_question(goldens.author_question(q)), prefix=prefix))
+                for qid, q in questions.items()]
+
+    def port(self, state, questions):
+        prefix = ref.prefix_ids(state, self.enc)
+        return [(qid, ref.render(state, q, self.enc, self.arrow, prefix=prefix)) for qid, q in questions.items()]
+
+    def test_shared_set_and_layout_cases(self):
+        seen = {"overflow": 0, "multi_state_block": 0, "rejected": 0, "budget_edge": 0}
+        for cid, state, questions in self.cases:
+            with self.subTest(cid):
+                try:
+                    want = self.author(state, questions)
+                except (self.up.QuestionError, self.up.InputBudgetError):
+                    with self.assertRaises((ref.QuestionError, ref.InputBudgetError)):
+                        self.port(state, questions)
+                    seen["rejected"] += 1
+                    continue
+                got = self.port(state, questions)
+                self.assertEqual([q for q, _ in got], [q for q, _ in want])
+                for (qid, g), (_, w) in zip(got, want):
+                    self.assertEqual(g.ids, w.ids, qid)
+                    self.assertEqual(g.slots, w.slots, qid)
+                    self.assertEqual(g.blocks, [tuple(b) for b in w.blocks], qid)
+                    self.assertEqual(g.names, w.names, qid)
+                    self.assertEqual(g.prefix_len, w.prefix_len, qid)
+                    self.assertEqual(g.catalogue_overflow, w.catalogue_overflow, qid)
+                    seen["overflow"] += w.catalogue_overflow
+                    seen["multi_state_block"] += len(w.state_blocks) > 1
+                    seen["budget_edge"] += len(w.ids) == ref.CONTEXT_LIMIT
+        # The set must exercise every form, or the test proves less than it says.
+        self.assertTrue(all(seen.values()), seen)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/crates/ollaya-decision/src/jev_style.rs b/crates/ollaya-decision/src/jev_style.rs
new file mode 100644
index 00000000..ed7457bd
--- /dev/null
+++ b/crates/ollaya-decision/src/jev_style.rs
@@ -0,0 +1,500 @@
+//! `jev-style-v1`: chaoliangUNSW/Jev-Style-2B-Decision-v3 (Apache-2.0), the "render v2" input
+//! (`macjev-render-v2-long-options`, layout `sb`) and its verdict readout.
+//!
+//! A port of the model's own self-contained runtime `jev_style_decision_gguf.py` (the "Shared core",
+//! byte-identical across its torch / mlx / gguf runtimes), `release_config.json` -> `runtime_parity`.
+//! Unlike `jevk5-v1` / `llm-logits-v1` this model is **not** a last-token label-logit readout:
+//!
+//!   * no chat template, no system prompt, no answer letters;
+//!   * the input is plain text, token segments encoded separately so slot positions are exact:
+//!
+//!     ```text
+//!     state prefix   State:\n<state>\n\n
+//!     short form     Question [<type>]: <question>\nOptions:\n
+//!     (q+opts+slots   - <option 1> ->\n ... - <option K> ->\n
+//!      <= 2048 tok)
+//!     overflow form  Question [<type>]: <question>\nOptions:\n
+//!     (otherwise)    Option 1: <option 1>\n ... Option K: <option K>\n        (the catalogue)
+//!                    Judge each numbered option in the complete catalogue above:\n
+//!                    Option 1 ->\n ... Option K ->\n                           (the rubric)
+//!     ```
+//!
+//!   * the score of option k is `logit(" yes") - logit(" no")` read at the k-th ` ->` slot, and the
+//!     probabilities are `softmax(scores / T)` in canonical option order, with ONE global temperature
+//!     (`readout_config.json` `temperatures.global` = 0.8278650620942867).
+//!
+//! The engine ([`crate::...`] via the llama runner) owns the decode: this module renders the token
+//! ids, the per-option verdict slots and the attention blocks; it does not read logits.
+//!
+//! The attention is block-causal in the model's 6 full-attention layers (every block attends to all
+//! earlier tokens and itself, no causal mask inside a block); the Gated-DeltaNet layers are recurrent.
+//! The blocks here tile `[0, len(ids))`: the state is cut into 2048-token blocks, the short question
+//! is one block, and in the overflow form the catalogue and the rubric are each cut into 2048 blocks.
+
+use serde::Deserialize;
+use serde_json::Value;
+
+use crate::Error;
+use crate::question::{Criteria, QType, Question};
+
+pub const LAYOUT: &str = "jev-style-v1";
+/// Attention block size (a processing unit, not a content limit).
+pub const BLOCK: usize = 2048;
+/// The complete input (state + question + options + readout) must fit this many tokens.
+pub const CONTEXT_LIMIT: usize = 25_600;
+
+/// `decision.json` of a `jev-style-v1` model: the three readout token ids (checked against the GGUF
+/// at load, as `readout_config.json` `slot_tokens`) and the one global calibration temperature.
+#[derive(Debug, Clone, Deserialize)]
+pub struct JevStyleConfig {
+    pub layout: String,
+    /// ` yes` token id (9542 in v3).
+    pub yes: u32,
+    /// ` no` token id (874).
+    pub no: u32,
+    /// ` ->` verdict-slot token id (1411).
+    pub arrow: u32,
+}
+
+impl JevStyleConfig {
+    pub fn validate(&self) -> Result<(), Error> {
+        if self.layout != LAYOUT {
+            return Err(Error::invalid(format!(
+                "decision.json: layout {:?} is not {LAYOUT}",
+                self.layout
+            )));
+        }
+        Ok(())
+    }
+}
+
+/// One rendered question: token ids, the verdict slots (one per option, canonical order), the
+/// attention blocks (`[start, stop)` pairs tiling `[0, ids.len())`) and the state-prefix length.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Rendered {
+    pub qtype: QType,
+    /// Option identifiers in canonical order = the order probabilities are returned.
+    pub names: Vec<String>,
+    pub ids: Vec<u32>,
+    pub prefix_len: usize,
+    /// Prompt position of each option's ` ->` slot, canonical order.
+    pub slots: Vec<usize>,
+    pub blocks: Vec<(usize, usize)>,
+    pub catalogue_overflow: bool,
+}
+
+impl Rendered {
+    pub fn input_tokens(&self) -> usize {
+        self.ids.len()
+    }
+}
+
+/// `serialize_state`: a string state passes through; any other JSON value is `json.dumps`ed
+/// (`ensure_ascii=False`).
+pub fn serialize_state(state: &Value) -> String {
+    match state {
+        Value::String(s) => s.clone(),
+        v => crate::pyjson::dumps(v, false),
+    }
+}
+
+/// Canonical option identifiers in probability order: a choice's labels, a score's level
+/// indices, or `["false", "true"]` for a noul. The shared parser ([`crate::question::Question`])
+/// has already validated and ordered them (and accepts a choice as a list of labels).
+fn canonical_names(q: &Question) -> Vec<String> {
+    match &q.criteria {
+        Criteria::Choice(m) => m.keys().cloned().collect(),
+        Criteria::Score(levels) => (0..levels.len()).map(|i| i.to_string()).collect(),
+        Criteria::Noul { .. } => vec!["false".into(), "true".into()],
+    }
+}
+
+/// `[(s, min(s + BLOCK, stop)) for s in range(start, stop, BLOCK)]`.
+fn blocks(start: usize, stop: usize) -> Vec<(usize, usize)> {
+    let mut out = Vec::new();
+    let mut s = start;
+    while s < stop {
+        out.push((s, (s + BLOCK).min(stop)));
+        s += BLOCK;
+    }
+    out
+}
+
+impl JevStyleConfig {
+    /// Render one wire question (`{type, instructions, criteria}`) into token ids, verdict slots and
+    /// attention blocks. `tokenize(text)` encodes with no BOS/EOS and special tokens split (never
+    /// control tokens), exactly as the runtime's `TextEncoder` does. Validation and the budget raise
+    /// [`Error`]; a tokenizer failure is the caller's `E`.
+    pub fn render<E: From<Error>>(
+        &self,
+        qid: &str,
+        q: &Question,
+        state_prefix: &[u32],
+        mut tokenize: impl FnMut(&str) -> Result<Vec<u32>, E>,
+    ) -> Result<Rendered, E> {
+        let bad = |m: String| E::from(Error::invalid(format!("question {qid:?}: {m}")));
+        // The shared parser accepts structured instructions (json.dumps) and 1..N score levels;
+        // jev-style keeps the author's stricter limits: a non-empty string and 2..=10 levels.
+        let ins = match q.definition.get("instructions") {
+            Some(Value::String(s)) if !s.trim().is_empty() => s.clone(),
+            _ => {
+                return Err(bad(
+                    "question text (instructions) must be a non-empty string".into(),
+                ));
+            }
+        };
+        if q.qtype == QType::Score && !(2..=10).contains(&q.num_options()) {
+            return Err(bad("score needs a list of 2..10 level descriptions".into()));
+        }
+        let qtype = q.qtype;
+        let names = canonical_names(q);
+        let bodies = q.render_options();
+
+        let head = tokenize(&format!("Question [{}]: {ins}\nOptions:\n", qtype.name()))?;
+        let opts: Vec<Vec<u32>> = bodies
+            .iter()
+            .map(|o| tokenize(o))
+            .collect::<Result<_, _>>()?;
+        let dash = tokenize("- ")?;
+        let newline = tokenize("\n")?;
+        let k = opts.len();
+        if k < 1 {
+            return Err(bad("at least one option is required".into()));
+        }
+
+        // short form: head, then `- <opt> ->\n` per option; the slot is the ` ->` position.
+        let mut short = head.clone();
+        let mut rel = Vec::with_capacity(k);
+        for o in &opts {
+            short.extend_from_slice(&dash);
+            short.extend_from_slice(o);
+            short.push(self.arrow);
+            rel.push(short.len() - 1);
+            short.extend_from_slice(&newline);
+        }
+        let overflow = short.len() > BLOCK;
+
+        let prefix_len = state_prefix.len();
+        let (ids, slots, blks) = if !overflow {
+            let mut ids = state_prefix.to_vec();
+            ids.extend_from_slice(&short);
+            let slots = rel.iter().map(|&s| prefix_len + s).collect();
+            let mut blks = blocks(0, prefix_len);
+            blks.push((prefix_len, ids.len()));
+            (ids, slots, blks)
+        } else {
+            // overflow form: a numbered catalogue, then a rubric of `Option k ->` slots.
+            let mut catalogue = head.clone();
+            for (pos, o) in opts.iter().enumerate() {
+                catalogue.extend(tokenize(&format!("Option {}: ", pos + 1))?);
+                catalogue.extend_from_slice(o);
+                catalogue.extend_from_slice(&newline);
+            }
+            let doc_end = prefix_len + catalogue.len();
+            let mut rubric =
+                tokenize("Judge each numbered option in the complete catalogue above:\n")?;
+            let mut rel = Vec::with_capacity(k);
+            for pos in 0..k {
+                rubric.extend(tokenize(&format!("Option {}", pos + 1))?);
+                rubric.push(self.arrow);
+                rel.push(rubric.len() - 1);
+                rubric.extend_from_slice(&newline);
+            }
+            let mut ids = state_prefix.to_vec();
+            ids.extend_from_slice(&catalogue);
+            ids.extend_from_slice(&rubric);
+            let slots = rel.iter().map(|&s| doc_end + s).collect();
+            let mut blks = blocks(0, prefix_len);
+            blks.extend(blocks(prefix_len, doc_end));
+            blks.extend(blocks(doc_end, ids.len()));
+            (ids, slots, blks)
+        };
+
+        if ids.len() > CONTEXT_LIMIT {
+            return Err(bad(format!(
+                "the complete input needs {} tokens (state {prefix_len} + question/options/readout \
+                 {}); the limit is {CONTEXT_LIMIT}. Nothing was truncated: shorten the state, the \
+                 question or the options.",
+                ids.len(),
+                ids.len() - prefix_len
+            )));
+        }
+        Ok(Rendered {
+            qtype,
+            names,
+            ids,
+            prefix_len,
+            slots,
+            blocks: blks,
+            catalogue_overflow: overflow,
+        })
+    }
+
+    /// The state prefix `State:\n<state>\n\n`, tokenised once and shared across a request's questions.
+    pub fn state_prefix<E>(
+        &self,
+        state: &Value,
+        mut tokenize: impl FnMut(&str) -> Result<Vec<u32>, E>,
+    ) -> Result<Vec<u32>, E> {
+        let mut ids = tokenize("State:\n")?;
+        ids.extend(tokenize(&serialize_state(state))?);
+        ids.extend(tokenize("\n\n")?);
+        Ok(ids)
+    }
+}
+
+/// `softmax(scores / T)` in f64, canonical option order (the reference computation).
+pub fn probabilities(scores: &[f64], temperature: f64) -> Vec<f64> {
+    if scores.is_empty() {
+        return Vec::new();
+    }
+    let max = scores.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
+    let exps: Vec<f64> = scores
+        .iter()
+        .map(|&s| ((s - max) / temperature).exp())
+        .collect();
+    let sum: f64 = exps.iter().sum();
+    exps.into_iter().map(|e| e / sum).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    const ARROW: u32 = 1411;
+
+    fn config() -> JevStyleConfig {
+        JevStyleConfig {
+            layout: LAYOUT.into(),
+            yes: 9542,
+            no: 874,
+            arrow: ARROW,
+        }
+    }
+
+    /// A character-level tokenizer: one token per char, except ` ->` (the verdict slot) which is the
+    /// single configured arrow id. Good enough to assert slot positions and reconstruct the text.
+    fn tok(text: &str) -> Result<Vec<u32>, Error> {
+        let mut ids = Vec::new();
+        let mut rest = text;
+        while let Some(c) = rest.chars().next() {
+            if let Some(stripped) = rest.strip_prefix(" ->") {
+                ids.push(ARROW);
+                rest = stripped;
+            } else {
+                ids.push(c as u32);
+                rest = &rest[c.len_utf8()..];
+            }
+        }
+        Ok(ids)
+    }
+
+    fn text_of(ids: &[u32]) -> String {
+        ids.iter()
+            .map(|&i| {
+                if i == ARROW {
+                    " ->".to_string()
+                } else {
+                    char::from_u32(i).unwrap().to_string()
+                }
+            })
+            .collect()
+    }
+
+    fn render(c: &JevStyleConfig, state: &Value, qid: &str, def: &Value) -> Rendered {
+        let prefix = c.state_prefix(state, tok).unwrap();
+        let q = crate::question::Question::parse(qid, def).unwrap();
+        c.render::<Error>(qid, &q, &prefix, tok).unwrap()
+    }
+
+    #[test]
+    fn short_form_choice_matches_reference() {
+        let c = config();
+        let r = render(
+            &c,
+            &json!("the order was billed twice"),
+            "team",
+            &json!({"type": "choice", "instructions": "Which team?",
+                    "criteria": {"billing": "cards", "tech": null, "sales": ""}}),
+        );
+        assert!(!r.catalogue_overflow);
+        assert_eq!(r.names, ["billing", "tech", "sales"]);
+        assert_eq!(
+            text_of(&r.ids),
+            "State:\nthe order was billed twice\n\n\
+             Question [choice]: Which team?\nOptions:\n\
+             - billing: cards ->\n- tech ->\n- sales ->\n"
+        );
+        // Each slot sits on a ` ->` arrow token.
+        for &s in &r.slots {
+            assert_eq!(r.ids[s], ARROW);
+        }
+        assert_eq!(r.slots.len(), 3);
+    }
+
+    #[test]
+    fn noul_and_score_bodies_match_reference() {
+        let c = config();
+        let n = render(
+            &c,
+            &json!("x"),
+            "q",
+            &json!({"type": "noul", "instructions": "Finished?"}),
+        );
+        assert_eq!(n.names, ["false", "true"]);
+        assert!(text_of(&n.ids).contains(
+            "- false: no, the statement does not hold ->\n- true: yes, the statement holds ->\n"
+        ));
+
+        let s = render(
+            &c,
+            &json!("x"),
+            "q",
+            &json!({"type": "score", "instructions": "How bad?", "criteria": ["calm", "tense", 2]}),
+        );
+        assert_eq!(s.names, ["0", "1", "2"]);
+        assert!(
+            text_of(&s.ids).contains("- level 0: calm ->\n- level 1: tense ->\n- level 2: 2 ->\n")
+        );
+    }
+
+    #[test]
+    fn state_is_serialized_like_json_dumps() {
+        let c = config();
+        let r = render(
+            &c,
+            &json!({"n": 1.5, "msg": "hi"}),
+            "q",
+            &json!({"type": "noul", "instructions": "ok?"}),
+        );
+        assert!(text_of(&r.ids).starts_with("State:\n{\"n\": 1.5, \"msg\": \"hi\"}\n\n"));
+    }
+
+    #[test]
+    fn overflow_switches_to_catalogue_and_rubric() {
+        let c = config();
+        // Many long options so the short block exceeds BLOCK tokens.
+        let crit: serde_json::Map<String, Value> = (0..200)
+            .map(|i| {
+                (
+                    format!("option_number_{i:03}_with_a_fairly_long_name"),
+                    Value::Null,
+                )
+            })
+            .collect();
+        let r = render(
+            &c,
+            &json!("s"),
+            "q",
+            &json!({"type": "choice", "instructions": "pick", "criteria": crit}),
+        );
+        assert!(r.catalogue_overflow);
+        assert_eq!(r.slots.len(), 200);
+        let t = text_of(&r.ids);
+        assert!(t.contains("Option 1: option_number_000"));
+        assert!(t.contains("Judge each numbered option in the complete catalogue above:\n"));
+        assert!(t.contains("Option 1 ->\n"));
+        for &s in &r.slots {
+            assert_eq!(r.ids[s], ARROW);
+        }
+    }
+
+    #[test]
+    fn blocks_tile_the_whole_input() {
+        let c = config();
+        let r = render(
+            &c,
+            &json!("hello"),
+            "q",
+            &json!({"type": "noul", "instructions": "ok?"}),
+        );
+        assert_eq!(r.blocks.first().unwrap().0, 0);
+        assert_eq!(r.blocks.last().unwrap().1, r.ids.len());
+        for w in r.blocks.windows(2) {
+            assert_eq!(w[0].1, w[1].0); // contiguous, no gaps/overlaps
+            assert!(w[0].1 - w[0].0 <= BLOCK);
+        }
+    }
+
+    /// Render through the shared parser, returning the error text instead of panicking.
+    fn render_err(def: &Value) -> String {
+        let c = config();
+        let prefix = c.state_prefix(&json!("s"), tok).unwrap();
+        let q = crate::question::Question::parse("q", def).unwrap();
+        c.render::<Error>("q", &q, &prefix, tok)
+            .unwrap_err()
+            .to_string()
+    }
+
+    #[test]
+    fn choice_as_a_list_of_labels_matches_reference() {
+        // ref.py: a list of labels is {label: None}; duplicates collapse onto their first position.
+        let r = render(
+            &config(),
+            &json!("s"),
+            "q",
+            &json!({"type": "choice", "instructions": "Which team?",
+                    "criteria": ["billing", "tech", "billing", "sales"]}),
+        );
+        assert_eq!(r.names, ["billing", "tech", "sales"]);
+        assert!(text_of(&r.ids).ends_with(
+            "Question [choice]: Which team?\nOptions:\n- billing ->\n- tech ->\n- sales ->\n"
+        ));
+        assert_eq!(r.slots.len(), 3);
+    }
+
+    #[test]
+    fn noul_keys_in_any_case_match_reference() {
+        // ref.py lower-cases the keys; the names stay ["false", "true"].
+        let r = render(
+            &config(),
+            &json!("s"),
+            "q",
+            &json!({"type": "noul", "instructions": "Finished?",
+                    "criteria": {"TRUE": "it is done", "False": "still open"}}),
+        );
+        assert_eq!(r.names, ["false", "true"]);
+        assert!(text_of(&r.ids).ends_with("- false: still open ->\n- true: it is done ->\n"));
+    }
+
+    #[test]
+    fn score_levels_outside_two_to_ten_are_rejected() {
+        for n in [1, 11] {
+            let levels: Vec<String> = (0..n).map(|i| format!("level {i}")).collect();
+            let e = render_err(&json!({"type": "score", "instructions": "How bad?",
+                                       "criteria": levels}));
+            assert!(e.contains("2..10 level descriptions"), "{n} levels: {e}");
+        }
+        for n in [2, 10] {
+            let levels: Vec<String> = (0..n).map(|i| format!("level {i}")).collect();
+            let r = render(
+                &config(),
+                &json!("s"),
+                "q",
+                &json!({"type": "score", "instructions": "How bad?", "criteria": levels}),
+            );
+            assert_eq!(r.slots.len(), n);
+        }
+    }
+
+    #[test]
+    fn non_string_or_blank_instructions_are_rejected() {
+        for ins in [
+            json!({"text": "ok?"}),
+            json!(["ok?"]),
+            json!(3),
+            json!("  "),
+        ] {
+            let e = render_err(&json!({"type": "noul", "instructions": ins}));
+            assert!(e.contains("non-empty string"), "{ins}: {e}");
+        }
+    }
+
+    #[test]
+    fn probabilities_softmax() {
+        let p = probabilities(&[2.0, 0.0], 1.0);
+        assert!((p[0] + p[1] - 1.0).abs() < 1e-12);
+        assert!(p[0] > p[1]);
+    }
+}
diff --git a/crates/ollaya-decision/src/lib.rs b/crates/ollaya-decision/src/lib.rs
index a030baee..f56dff1a 100644
--- a/crates/ollaya-decision/src/lib.rs
+++ b/crates/ollaya-decision/src/lib.rs
@@ -21,6 +21,7 @@ pub mod gliclass;
 pub mod gliclass_kv;
 pub mod jebadiah;
 pub mod jeeves;
+pub mod jev_style;
 pub mod jevk5;
 pub mod kev;
 pub mod layout;
diff --git a/crates/ollaya-runner/examples/parity_jev_style.rs b/crates/ollaya-runner/examples/parity_jev_style.rs
new file mode 100644
index 00000000..71560cde
--- /dev/null
+++ b/crates/ollaya-runner/examples/parity_jev_style.rs
@@ -0,0 +1,286 @@
+//! Compare the llama.cpp engine on `jev-style-v1` (chaoliangUNSW/Jev-Style-2B-Decision-v3) against
+//! golden fixtures from `ollaya_convert.families.jev_style.goldens`: the author's own render
+//! (`jev_style_decision_gguf.py`) scored by the author's `jev-score-v2`, unchanged, on the same pinned
+//! llama.cpp build (b11146) and device.
+//!
+//!     cargo run --release -p ollaya-runner --example parity_jev_style -- \
+//!         <model-dir> <goldens.jsonl> [auto|cpu|cuda|cuda:<n>] [--smoke]
+//!
+//! `<model-dir>` holds `decision.json`, `calibration.json`, `model.gguf` (the author's GGUF, or a
+//! link to it) and `tokenizer.json` (the author's `tokenizer/tokenizer.json`, the package's tokenizer
+//! layer). llama.cpp is loaded from `$OLLAYA_LIBRARY_PATH/llama`, and its CUDA backend from
+//! `$OLLAYA_LIBRARY_PATH/cuda_v13/libggml-cuda.so` or, failing that, `cuda_v12/libggml-cuda.so`.
+//!
+//! Every case is rendered first:
+//! * a request the reference rejects must be rejected;
+//! * per question: the token ids, the verdict slots, the attention blocks and the option names
+//!   must be identical, and so must the state's token count.
+//!
+//! Then every question is scored:
+//! * each verdict score `logit(" yes") - logit(" no")` within `SCORE_TOL` of jev-score-v2's;
+//! * the calibrated probabilities (`calibration.json`, the author's one global temperature) must
+//!   pick the reference's option; their difference is reported as max and p99.
+//!
+//! It prints one `record:` JSON line for `ollaya_convert.parity_run` before its checks.
+
+use std::path::PathBuf;
+use std::time::Instant;
+
+use ollaya_decision::{Calibration, CalibrationFile, QType};
+use ollaya_runner::llama::{Libraries, LlamaModel, Target};
+use serde_json::Value;
+
+mod smoke;
+
+/// Largest verdict-score difference accepted: the family tolerance of every Ollaya parity check.
+const SCORE_TOL: f64 = 1e-3;
+
+fn argmax(p: &[f64]) -> usize {
+    p.iter()
+        .enumerate()
+        .fold(
+            (0, f64::NEG_INFINITY),
+            |b, (i, &v)| if v > b.1 { (i, v) } else { b },
+        )
+        .0
+}
+
+fn percentile(sorted: &[f64], p: usize) -> f64 {
+    sorted
+        .get((sorted.len() * p / 100).min(sorted.len().saturating_sub(1)))
+        .copied()
+        .unwrap_or(0.0)
+}
+
+fn qtype(def: &Value) -> QType {
+    match def["type"].as_str() {
+        Some("choice") => QType::Choice,
+        Some("score") => QType::Score,
+        _ => QType::Noul,
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let (args, smoke) = smoke::args();
+    let pos: Vec<&String> = args[1..].iter().filter(|a| !a.starts_with("--")).collect();
+    if pos.len() < 2 {
+        return Err(
+            "usage: parity_jev_style <model-dir> <goldens.jsonl> [auto|cpu|cuda|cuda:<n>] [--smoke]"
+                .into(),
+        );
+    }
+    let dir = PathBuf::from(pos[0]);
+    let goldens = PathBuf::from(pos[1]);
+    let target = match pos.get(2).map(|s| s.as_str()).unwrap_or("auto") {
+        "auto" => Target::Auto,
+        "cpu" => Target::Cpu,
+        "cuda" => Target::Device("CUDA0".into()),
+        d => Target::Device(
+            d.strip_prefix("cuda:")
+                .map(|n| format!("CUDA{n}"))
+                .unwrap_or_else(|| d.to_owned()),
+        ),
+    };
+    let lib = std::env::var_os("OLLAYA_LIBRARY_PATH")
+        .map(PathBuf::from)
+        .ok_or("set OLLAYA_LIBRARY_PATH to an install's lib/ollaya")?;
+    let cuda = ["cuda_v13", "cuda_v12"]
+        .map(|pack| lib.join(pack).join(ollaya_runner::llama::CUDA_BACKEND))
+        .into_iter()
+        .find(|p| p.is_file());
+    let libs = Libraries {
+        dir: lib.join("llama"),
+        cuda,
+        rocm: None,
+    };
+    let calibration: CalibrationFile =
+        serde_json::from_str(&std::fs::read_to_string(dir.join("calibration.json"))?)?;
+    let calibration = Calibration::from_file(&calibration);
+
+    let t0 = Instant::now();
+    let mut model = LlamaModel::load(
+        &dir.join("model.gguf"),
+        &dir.join("decision.json"),
+        &libs,
+        &target,
+        None,
+    )?;
+    model.load_tokenizer(&dir.join("tokenizer.json"))?;
+    let dev = model.device.clone();
+    println!(
+        "loaded {} on {dev} in {:.1}s",
+        model.precision,
+        t0.elapsed().as_secs_f64()
+    );
+
+    let (mut cases, mut rejected, mut questions, mut agree) = (0usize, 0usize, 0usize, 0usize);
+    let mut failures: Vec<String> = Vec::new();
+    let mut score_diffs: Vec<f64> = Vec::new();
+    let mut prob_diffs: Vec<f64> = Vec::new();
+    let t_eval = Instant::now();
+    for line in smoke::lines(&goldens, smoke)? {
+        let case: Value = serde_json::from_str(&line)?;
+        let id = case["id"].as_str().unwrap_or("?").to_owned();
+        cases += 1;
+        let render = model.jev_style_render(&case["state"], &case["questions"]);
+        if case.get("error").is_some() {
+            rejected += 1;
+            // The engine may reject at render time or, for the context check, when it runs.
+            let accepted =
+                render.is_ok() && model.run_json(&case["state"], &case["questions"]).is_ok();
+            if accepted {
+                failures.push(format!(
+                    "{id}: accepted; the reference rejects it ({})",
+                    case["message"].as_str().unwrap_or("")
+                ));
+            }
+            continue;
+        }
+        let (prefix, rendered) = match render {
+            Ok(r) => r,
+            Err(e) => {
+                failures.push(format!("{id}: rejected ({e}); the reference accepts it"));
+                continue;
+            }
+        };
+        if prefix.len() as u64 != case["state_tokens"].as_u64().unwrap_or(u64::MAX) {
+            failures.push(format!(
+                "{id}: state {} tokens, the reference {}",
+                prefix.len(),
+                case["state_tokens"]
+            ));
+        }
+        let rows = case["rows"].as_array().cloned().unwrap_or_default();
+        if rows.len() != rendered.len() {
+            failures.push(format!(
+                "{id}: {} questions, the reference {}",
+                rendered.len(),
+                rows.len()
+            ));
+            continue;
+        }
+        let mut same = true;
+        for ((qid, r), want) in rendered.iter().zip(&rows) {
+            let mut bad = Vec::new();
+            if qid != want["qid"].as_str().unwrap_or("") {
+                bad.push(format!("order ({})", want["qid"]));
+            }
+            let w: Vec<u32> = serde_json::from_value(want["ids"].clone()).unwrap_or_default();
+            if r.ids != w {
+                let at = r.ids.iter().zip(&w).take_while(|(a, b)| a == b).count();
+                bad.push(format!(
+                    "token ids differ at {at} ({} vs {} tokens)",
+                    r.ids.len(),
+                    w.len()
+                ));
+            }
+            let slots: Vec<usize> =
+                serde_json::from_value(want["slots"].clone()).unwrap_or_default();
+            if r.slots != slots {
+                bad.push("slots".into());
+            }
+            let blocks: Vec<(usize, usize)> =
+                serde_json::from_value(want["blocks"].clone()).unwrap_or_default();
+            if r.blocks != blocks {
+                bad.push(format!("blocks {:?} vs {blocks:?}", r.blocks));
+            }
+            let names: Vec<String> =
+                serde_json::from_value(want["names"].clone()).unwrap_or_default();
+            if r.names != names {
+                bad.push("option names".into());
+            }
+            if r.catalogue_overflow != want["catalogue_overflow"].as_bool().unwrap_or(false) {
+                bad.push("catalogue overflow".into());
+            }
+            if !bad.is_empty() {
+                same = false;
+                failures.push(format!("{id}/{qid}: {}", bad.join(", ")));
+            }
+        }
+        if !same {
+            continue;
+        }
+        let out = match model.run_json(&case["state"], &case["questions"]) {
+            Ok(o) => o,
+            Err(e) => {
+                failures.push(format!("{id}: scoring failed ({e})"));
+                continue;
+            }
+        };
+        for (((qid, _), got), want) in rendered.iter().zip(&out.questions).zip(&rows) {
+            questions += 1;
+            let want_scores: Vec<f64> = serde_json::from_value(want["scores"].clone())?;
+            let got = &got.logits;
+            if got.len() != want_scores.len() {
+                failures.push(format!(
+                    "{id}/{qid}: {} scores, the reference {}",
+                    got.len(),
+                    want_scores.len()
+                ));
+                continue;
+            }
+            let diff = got
+                .iter()
+                .zip(&want_scores)
+                .map(|(&a, &b)| (f64::from(a) - b).abs())
+                .fold(0.0, f64::max);
+            score_diffs.push(diff);
+            if diff > SCORE_TOL || diff.is_nan() {
+                failures.push(format!("{id}/{qid}: verdict scores differ by {diff:.3e}"));
+            }
+            let t = qtype(&case["questions"][qid]);
+            let p_got = calibration.probabilities(t, got, prefix.len());
+            let want32: Vec<f32> = want_scores.iter().map(|&x| x as f32).collect();
+            let p_want = calibration.probabilities(t, &want32, prefix.len());
+            let pd = p_got
+                .iter()
+                .zip(&p_want)
+                .map(|(a, b)| (a - b).abs())
+                .fold(0.0, f64::max);
+            prob_diffs.push(pd);
+            if argmax(&p_got) == argmax(&p_want) {
+                agree += 1;
+            } else {
+                failures.push(format!(
+                    "{id}/{qid}: the decision differs (p diff {pd:.3e})"
+                ));
+            }
+        }
+    }
+    let eval_s = t_eval.elapsed().as_secs_f64();
+    score_diffs.sort_by(f64::total_cmp);
+    prob_diffs.sort_by(f64::total_cmp);
+    println!(
+        "{cases} cases ({rejected} rejected), {questions} questions on {dev} in {eval_s:.1}s: \
+         decisions {agree}/{questions} ({:.2}%), verdict scores max {:.3e} p99 {:.3e}, \
+         probabilities max {:.3e} p99 {:.3e}",
+        100.0 * agree as f64 / questions.max(1) as f64,
+        score_diffs.last().copied().unwrap_or(0.0),
+        percentile(&score_diffs, 99),
+        prob_diffs.last().copied().unwrap_or(0.0),
+        percentile(&prob_diffs, 99),
+    );
+    // One JSON line for `ollaya_convert.parity_run`, which records it in results/runs/.
+    println!(
+        "record: {}",
+        serde_json::json!({
+            "questions": questions,
+            "decisions_same": agree,
+            "max_logit_diff": score_diffs.last().copied().unwrap_or(0.0),
+            "max_prob_diff": prob_diffs.last().copied().unwrap_or(0.0),
+            "p99_prob_diff": percentile(&prob_diffs, 99),
+        })
+    );
+    // An empty or truncated goldens file (an export that stopped early) must not pass the gate.
+    if questions == 0 {
+        return Err(format!("{}: no questions to check", goldens.display()).into());
+    }
+    if !failures.is_empty() {
+        for f in failures.iter().take(40) {
+            eprintln!("FAIL {f}");
+        }
+        return Err(format!("{} failures", failures.len()).into());
+    }
+    println!("PASS");
+    Ok(())
+}
diff --git a/crates/ollaya-runner/src/llama/ffi.rs b/crates/ollaya-runner/src/llama/ffi.rs
index 254bb031..6307d001 100644
--- a/crates/ollaya-runner/src/llama/ffi.rs
+++ b/crates/ollaya-runner/src/llama/ffi.rs
@@ -135,6 +135,8 @@ pub struct Api {
     pub llama_get_memory: unsafe extern "C" fn(*const c_void) -> *mut c_void,
     pub llama_memory_clear: unsafe extern "C" fn(*mut c_void, bool),
     pub llama_memory_seq_rm: unsafe extern "C" fn(*mut c_void, SeqId, Pos, Pos) -> bool,
+    pub llama_memory_seq_cp: unsafe extern "C" fn(*mut c_void, SeqId, SeqId, Pos, Pos),
+    pub llama_synchronize: unsafe extern "C" fn(*mut c_void),
     pub llama_decode: unsafe extern "C" fn(*mut c_void, Batch) -> i32,
     pub llama_get_logits_ith: unsafe extern "C" fn(*mut c_void, i32) -> *mut f32,
     pub llama_n_ctx: unsafe extern "C" fn(*const c_void) -> u32,
@@ -220,6 +222,8 @@ impl Api {
             llama_get_memory: sym!(llama, llama_get_memory),
             llama_memory_clear: sym!(llama, llama_memory_clear),
             llama_memory_seq_rm: sym!(llama, llama_memory_seq_rm),
+            llama_memory_seq_cp: sym!(llama, llama_memory_seq_cp),
+            llama_synchronize: sym!(llama, llama_synchronize),
             llama_decode: sym!(llama, llama_decode),
             llama_get_logits_ith: sym!(llama, llama_get_logits_ith),
             llama_n_ctx: sym!(llama, llama_n_ctx),
diff --git a/crates/ollaya-runner/src/llama/mod.rs b/crates/ollaya-runner/src/llama/mod.rs
index 37fb4ed2..4260197e 100644
--- a/crates/ollaya-runner/src/llama/mod.rs
+++ b/crates/ollaya-runner/src/llama/mod.rs
@@ -29,6 +29,7 @@ use ollaya_decision::Questions;
 use ollaya_decision::cygnet::{self, CygnetConfig};
 use ollaya_decision::d1::{self, D1Config};
 use ollaya_decision::jebadiah::{self, JebadiahConfig};
+use ollaya_decision::jev_style::{self, JevStyleConfig};
 use ollaya_decision::jevk5::{self, JevK5Config};
 use ollaya_decision::llm_logits::{self, LlmLogitsConfig};
 use ollaya_decision::snap::{self, SnapConfig};
@@ -44,6 +45,7 @@ pub const LAYOUTS: &[&str] = &[
     llm_logits::LAYOUT,
     winnow::LAYOUT,
     jevk5::LAYOUT,
+    jev_style::LAYOUT,
     jebadiah::LAYOUT,
     cygnet::LAYOUT,
     snap::LAYOUT,
@@ -66,6 +68,31 @@ pub struct LlamaSettings {
     /// `prefix` (the shared-prefix plan) or `cold` (one cold pass per question).
     #[serde(default = "prefix_plan")]
     pub plan: String,
+    /// llama_context attention_type: -1 causal (default), 1 non-causal (jev-style blocks).
+    #[serde(default = "attn_causal")]
+    pub attention_type: i32,
+    #[serde(default = "ubatch_default")]
+    pub n_ubatch: u32,
+    #[serde(default = "nseq_default")]
+    pub n_seq_max: u32,
+    #[serde(default)]
+    pub n_outputs_max: u32,
+    /// A unified KV cache: one shared pool so each sequence can use the whole context
+    /// (jev-style copies the prefix to sequence 1). The default splits it across sequences.
+    #[serde(default)]
+    pub kv_unified: bool,
+}
+
+fn attn_causal() -> i32 {
+    -1
+}
+
+fn ubatch_default() -> u32 {
+    512
+}
+
+fn nseq_default() -> u32 {
+    1
 }
 
 fn prefix_plan() -> String {
@@ -123,6 +150,7 @@ enum Layout {
     },
     Winnow(WinnowConfig),
     JevK5(JevK5Config),
+    JevStyle(JevStyleConfig),
     Jebadiah(JebadiahConfig),
     Cygnet {
         cfg: Box<CygnetConfig>,
@@ -210,6 +238,9 @@ pub struct LlamaModel {
     vocab: Vocab,
     layout: Layout,
     settings: LlamaSettings,
+    /// The author's `tokenizer.json`, for a layout that renders with it instead of the GGUF's
+    /// vocabulary (jev-style: llama.cpp's pre-tokenizer splits some scripts differently).
+    tokenizer: Option<tokenizers::Tokenizer>,
     /// `cuda:0`, `metal` or `cpu`.
     pub device: String,
     /// The GGUF's type (`Q8_0`).
@@ -572,6 +603,45 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
             cfg.validate().map_err(bad)?;
             Layout::JevK5(cfg)
         }
+        Some(jev_style::LAYOUT) => {
+            let cfg: JevStyleConfig =
+                serde_json::from_value(decision.clone()).map_err(parse_error)?;
+            cfg.validate().map_err(bad)?;
+            // The verdict readout tokens must be this GGUF's.
+            for (text, id) in [(" yes", cfg.yes), (" no", cfg.no), (" ->", cfg.arrow)] {
+                let got = vocab.tokenize(text, false, false)?;
+                if got != [id as Token] {
+                    return Err(model_error(format!(
+                        "jev-style: {text:?} is {got:?} in this GGUF, decision.json says [{id}]"
+                    )));
+                }
+            }
+            // The context must be the non-causal, wide-ubatch one jev-score-v2 needs.
+            let llama = &decision["llama"];
+            if llama.get("attention_type").and_then(Value::as_i64) != Some(1) {
+                return Err(model_error(
+                    "jev-style: decision.json llama.attention_type must be 1 (non-causal block \
+                     attention); a causal context would score every option against the wrong \
+                     attention",
+                ));
+            }
+            let n_ubatch = llama.get("n_ubatch").and_then(Value::as_u64).unwrap_or(512);
+            if n_ubatch < jev_style::BLOCK as u64 {
+                return Err(model_error(format!(
+                    "jev-style: decision.json llama.n_ubatch is {n_ubatch}; it must be at least \
+                     {} so a full attention block fits one ubatch",
+                    jev_style::BLOCK
+                )));
+            }
+            let n_seq_max = llama.get("n_seq_max").and_then(Value::as_u64).unwrap_or(1);
+            if n_seq_max < 2 {
+                return Err(model_error(format!(
+                    "jev-style: decision.json llama.n_seq_max is {n_seq_max}; it must be at least \
+                     2 (the state in sequence 0, each question copied into sequence 1)"
+                )));
+            }
+            Layout::JevStyle(cfg)
+        }
         Some(jebadiah::LAYOUT) => {
             let cfg: JebadiahConfig =
                 serde_json::from_value(decision.clone()).map_err(parse_error)?;
@@ -636,6 +706,7 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
         }
         Layout::Winnow(cfg) => vec![&cfg.labels],
         Layout::JevK5(cfg) => vec![&cfg.labels],
+        Layout::JevStyle(_) => vec![],
         Layout::Jebadiah(cfg) => vec![&cfg.labels],
         Layout::Cygnet { cfg, .. } => vec![&cfg.labels],
         Layout::Snap { cfg, .. } => vec![&cfg.labels],
@@ -653,7 +724,199 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
     Ok(layout)
 }
 
+/// A `jev-style-v1` request's state prefix and each question's render, in request order.
+pub type JevStyleRender = (Vec<u32>, Vec<(String, jev_style::Rendered)>);
+
 impl LlamaModel {
+    /// `jev-style-v1` (chaoliangUNSW/Jev-Style-2B-Decision-v3): non-causal block attention + verdict
+    /// readout, mirroring the model's own jev-score-v2. The state decodes into sequence 0 once; each
+    /// question copies sequence 0 -> 1, decodes its question-side blocks into sequence 1 (logits only
+    /// at the ` ->` slots), reads `logit(" yes") - logit(" no")` at each slot, then clears sequence 1.
+    /// The one global temperature is applied by the calibration layer, as for every family.
+    fn run_jev_style(
+        &self,
+        state: &Value,
+        questions: &Value,
+        cfg: &JevStyleConfig,
+    ) -> Result<Output, Error> {
+        let api = self.handles.api;
+        let (prefix, rendered) = self.render_jev_style(state, questions, cfg)?;
+        // Reject an input the context cannot hold, before any decode (a clean 422, not a 500
+        // from inside llama_decode). A unified KV cache lets each sequence use the whole context.
+        let capacity = if self.settings.kv_unified {
+            self.settings.n_ctx
+        } else {
+            self.settings.n_ctx / (self.settings.n_seq_max.max(1) as usize)
+        };
+        for (qid, r) in &rendered {
+            if r.ids.len() > capacity {
+                return Err(ollaya_decision::Error::invalid(format!(
+                    "question {qid:?}: the rendered input is {} tokens, over the model's \
+                     {capacity}-token context; shorten the state, question or options",
+                    r.ids.len()
+                ))
+                .into());
+            }
+        }
+
+        let mut guard = self
+            .handles
+            .context
+            .lock()
+            .map_err(|_| model_error("context mutex poisoned"))?;
+        let ctx = &mut *guard;
+        self.clear(ctx);
+        let mut p = 0usize;
+        while p < prefix.len() {
+            let e = (p + jev_style::BLOCK).min(prefix.len());
+            self.decode_block(ctx, &prefix[p..e], p, 0, &[])?;
+            p = e;
+        }
+        // SAFETY: the context is live and locked for the whole request.
+        unsafe { (api.llama_synchronize)(ctx.ptr.as_ptr()) };
+        ctx.prefix = None;
+
+        let (yes, no) = (cfg.yes as usize, cfg.no as usize);
+        let mut out = Vec::with_capacity(rendered.len());
+        let mut input_tokens = prefix.len();
+        for (_, r) in &rendered {
+            input_tokens += r.ids.len() - r.prefix_len;
+            // SAFETY: the memory belongs to this context.
+            unsafe {
+                (api.llama_memory_seq_rm)(ctx.memory, 1, -1, -1);
+                if !prefix.is_empty() {
+                    (api.llama_memory_seq_cp)(ctx.memory, 0, 1, -1, -1);
+                }
+            }
+            let mut scores = vec![f32::NAN; r.slots.len()];
+            for &(a, b) in r.blocks.iter().filter(|&&(a, _)| a >= r.prefix_len) {
+                let got = self.decode_block(ctx, &r.ids[a..b], a, 1, &r.slots)?;
+                for (w, rel) in got {
+                    // SAFETY: logits for `rel` are live until the next decode overwrites them.
+                    let ptr = unsafe { (api.llama_get_logits_ith)(ctx.ptr.as_ptr(), rel) };
+                    if ptr.is_null() {
+                        return Err(model_error("jev-style: no logits at a verdict slot"));
+                    }
+                    // SAFETY: the row has n_tokens entries; no decode runs during the read.
+                    let lg = unsafe { std::slice::from_raw_parts(ptr, self.vocab.n_tokens) };
+                    let y = *lg
+                        .get(yes)
+                        .ok_or_else(|| model_error("jev-style: 'yes' id outside the vocabulary"))?;
+                    let n = *lg
+                        .get(no)
+                        .ok_or_else(|| model_error("jev-style: 'no' id outside the vocabulary"))?;
+                    scores[w] = y - n;
+                }
+            }
+            // SAFETY: the memory belongs to this context.
+            unsafe { (api.llama_memory_seq_rm)(ctx.memory, 1, -1, -1) };
+            if scores.iter().any(|s| !s.is_finite()) {
+                return Err(model_error(
+                    "jev-style: a verdict slot produced a non-finite score (NaN or infinite)",
+                ));
+            }
+            out.push(QuestionOutput {
+                logits: scores,
+                act_logits: None,
+            });
+        }
+        Ok(Output {
+            questions: out,
+            input_tokens,
+            state_tokens: prefix.len(),
+            state_truncated: false,
+        })
+    }
+
+    /// `jev-style-v1`: the state prefix and each question's render (ids, verdict slots, attention
+    /// blocks) with this GGUF's tokenizer, as [`Self::run_json`] decodes them. For the parity gate.
+    pub fn jev_style_render(
+        &self,
+        state: &Value,
+        questions: &Value,
+    ) -> Result<JevStyleRender, Error> {
+        match &self.layout {
+            Layout::JevStyle(cfg) => self.render_jev_style(state, questions, cfg),
+            _ => Err(model_error("not a jev-style model")),
+        }
+    }
+
+    fn render_jev_style(
+        &self,
+        state: &Value,
+        questions: &Value,
+        cfg: &JevStyleConfig,
+    ) -> Result<JevStyleRender, Error> {
+        let parsed = ollaya_decision::parse_questions(questions)?;
+        let tokenizer = self.tokenizer.as_ref().ok_or_else(|| {
+            model_error(
+                "jev-style renders with the author's tokenizer.json, and this model has none \
+                 (the package's tokenizer layer)",
+            )
+        })?;
+        let mut tok = |t: &str| {
+            tokenizer
+                .encode(t, false)
+                .map(|e| e.get_ids().to_vec())
+                .map_err(|e| Error::Decision(ollaya_decision::Error::Tokenizer(e.to_string())))
+        };
+        let prefix = cfg.state_prefix(state, &mut tok)?;
+        let rendered = parsed
+            .iter()
+            .map(|(qid, q)| Ok((qid.clone(), cfg.render::<Error>(qid, q, &prefix, &mut tok)?)))
+            .collect::<Result<_, Error>>()?;
+        Ok((prefix, rendered))
+    }
+
+    /// Decode one renderer block: `ids[lo..hi]` at positions `pos0..` into sequence `seq`, with the
+    /// logits requested only at the absolute positions in `want` that fall inside the block. Returns
+    /// `(want index, batch index)` pairs for reading those logits.
+    fn decode_block(
+        &self,
+        ctx: &mut Context,
+        block: &[u32],
+        pos0: usize,
+        seq: ffi::SeqId,
+        want: &[usize],
+    ) -> Result<Vec<(usize, i32)>, Error> {
+        let n = block.len();
+        if n == 0 || n as u32 > self.settings.n_ubatch {
+            return Err(model_error(
+                "jev-style: block length exceeds the context ubatch",
+            ));
+        }
+        let mut token: Vec<Token> = block.iter().map(|&x| x as Token).collect();
+        let mut pos: Vec<ffi::Pos> = (0..n).map(|k| (pos0 + k) as ffi::Pos).collect();
+        let mut n_seq_id = vec![1i32; n];
+        let mut seq_arr = [seq];
+        let mut seq_id: Vec<*mut ffi::SeqId> = vec![seq_arr.as_mut_ptr(); n];
+        let mut logits = vec![0i8; n];
+        let mut got = Vec::new();
+        for (w, &slot) in want.iter().enumerate() {
+            if slot >= pos0 && slot < pos0 + n {
+                let rel = slot - pos0;
+                logits[rel] = 1;
+                got.push((w, rel as i32));
+            }
+        }
+        let batch = Batch {
+            n_tokens: n as i32,
+            token: token.as_mut_ptr(),
+            embd: std::ptr::null_mut(),
+            pos: pos.as_mut_ptr(),
+            n_seq_id: n_seq_id.as_mut_ptr(),
+            seq_id: seq_id.as_mut_ptr(),
+            logits: logits.as_mut_ptr(),
+        };
+        // SAFETY: every array holds `n` entries (`seq_arr` one) and outlives the decode.
+        let rc = unsafe { (self.handles.api.llama_decode)(ctx.ptr.as_ptr(), batch) };
+        if rc != 0 {
+            return Err(model_error(format!(
+                "jev-style: llama_decode failed ({rc})"
+            )));
+        }
+        Ok(got)
+    }
     /// Load `gguf` with the layout of its `decision.json`, on `target`.
     pub fn load(
         gguf: &Path,
@@ -763,6 +1026,7 @@ impl LlamaModel {
             vocab,
             layout,
             settings: d.llama.clone(),
+            tokenizer: None,
             device,
             precision: d.gguf.quantization.clone(),
         };
@@ -770,6 +1034,33 @@ impl LlamaModel {
         Ok(model)
     }
 
+    /// Attach the author's `tokenizer.json` (the package's tokenizer layer) to a jev-style model,
+    /// which renders with it as the author's runtime does: no BOS/EOS, special tokens in user text
+    /// split (never control tokens). The readout tokens must be single tokens there too.
+    pub fn load_tokenizer(&mut self, path: &Path) -> Result<(), Error> {
+        let Layout::JevStyle(cfg) = &self.layout else {
+            return Err(model_error(
+                "a tokenizer.json is only used by jev-style GGUF models",
+            ));
+        };
+        let mut tok = crate::onnx::load_tokenizer(path)?;
+        tok.set_encode_special_tokens(true);
+        for (text, id) in [(" yes", cfg.yes), (" no", cfg.no), (" ->", cfg.arrow)] {
+            let got = tok
+                .encode(text, false)
+                .map_err(|e| model_error(format!("{}: {e}", path.display())))?;
+            if got.get_ids() != [id] {
+                return Err(model_error(format!(
+                    "jev-style: {text:?} is {:?} in {}, decision.json says [{id}]",
+                    got.get_ids(),
+                    path.display()
+                )));
+            }
+        }
+        self.tokenizer = Some(tok);
+        Ok(())
+    }
+
     /// Attach a matching GGUF projector. Text-only loads need no libmtmd.
     pub fn load_projector(
         &mut self,
@@ -1015,6 +1306,9 @@ impl LlamaModel {
     pub fn encode(&self, state: &Value, questions: &Value) -> Result<Encoded, Error> {
         let vocab = &self.vocab;
         match &self.layout {
+            Layout::JevStyle(_) => Err(model_error(
+                "internal: jev-style decisions are produced by run_jev_style",
+            )),
             Layout::LlmLogits {
                 cfg,
                 pre,
@@ -1456,6 +1750,9 @@ impl LlamaModel {
 
     /// Encode and evaluate a request: the runner contract's output.
     pub fn run_json(&self, state: &Value, questions: &Value) -> Result<Output, Error> {
+        if let Layout::JevStyle(cfg) = &self.layout {
+            return self.run_jev_style(state, questions, cfg);
+        }
         let enc = self.encode(state, questions)?;
         let logits = self.evaluate(&enc)?;
         Ok(Output {
@@ -1507,12 +1804,21 @@ fn load_on(
         let mut cp = (api.llama_context_default_params)();
         cp.n_ctx = settings.n_ctx as u32;
         cp.n_batch = N_BATCH as u32;
-        cp.n_ubatch = N_UBATCH;
-        cp.n_seq_max = 1;
+        cp.n_ubatch = settings.n_ubatch;
+        cp.n_seq_max = settings.n_seq_max;
+        cp.attention_type = settings.attention_type;
+        cp.n_outputs_max = settings.n_outputs_max;
+        cp.n_outputs_max_per_seq = settings.n_outputs_max.max(1);
+        // Flash attention stays on auto (-1) by default. The non-causal block model
+        // (jev-style, attention_type 1) follows jev-score-v2: off on the CPU, where the
+        // author measured a precision loss, and auto on a GPU.
+        if settings.attention_type == 1 && device.is_none() {
+            cp.flash_attn_type = 0; // LLAMA_FLASH_ATTN_TYPE_DISABLED
+        }
         cp.n_threads = threads;
         cp.n_threads_batch = threads;
         cp.swa_full = settings.swa_full;
-        cp.kv_unified = false;
+        cp.kv_unified = settings.kv_unified;
         cp.no_perf = true;
         let ctx = (api.llama_init_from_model)(model.as_ptr(), cp);
         if ctx.is_null() {
@@ -1690,7 +1996,12 @@ mod tests {
             LlamaSettings {
                 n_ctx: 8192,
                 swa_full: false,
-                plan: "prefix".into()
+                plan: "prefix".into(),
+                attention_type: -1,
+                n_ubatch: 512,
+                n_seq_max: 1,
+                n_outputs_max: 0,
+                kv_unified: false,
             }
         );
     }
diff --git a/crates/ollaya-runner/src/server.rs b/crates/ollaya-runner/src/server.rs
index 56c3b876..c58fb1df 100644
--- a/crates/ollaya-runner/src/server.rs
+++ b/crates/ollaya-runner/src/server.rs
@@ -173,6 +173,9 @@ fn load_llama(config: &RunnerConfig, gguf: &Path) -> Result<(Box<dyn Engine>, Lo
         model,
         allow_fallback,
         |model| {
+            if let Some(tokenizer) = &config.tokenizer {
+                model.load_tokenizer(tokenizer)?;
+            }
             if let Some(projector) = &config.mmproj {
                 model.load_projector(projector, &libs, config.threads)?;
             }
diff --git a/crates/ollaya-server/src/models.rs b/crates/ollaya-server/src/models.rs
index 4480e539..876bb137 100644
--- a/crates/ollaya-server/src/models.rs
+++ b/crates/ollaya-server/src/models.rs
@@ -30,6 +30,8 @@ pub struct RunnerFiles {
 #[derive(Debug, Clone, PartialEq)]
 pub struct LlamaFiles {
     pub mmproj: Option<PathBuf>,
+    /// The author's `tokenizer.json`, for a layout that renders with it (jev-style).
+    pub tokenizer: Option<PathBuf>,
     pub gguf: PathBuf,
     pub decision: PathBuf,
     /// The GGUF's type (`Q4_0`), from the layer's annotation.
@@ -137,6 +139,10 @@ pub fn resolve_entry(store: &Store, entry: Entry) -> Result<Resolved, Error> {
                 .layer(media::MMPROJ)
                 .map(|d| store.blob_path(&d.digest))
                 .transpose()?,
+            tokenizer: manifest
+                .layer(media::TOKENIZER)
+                .map(|d| store.blob_path(&d.digest))
+                .transpose()?,
             gguf: blob(media::GGUF)?,
             decision: blob(media::DECISION)?,
             quantization,
diff --git a/crates/ollaya-server/src/scheduler.rs b/crates/ollaya-server/src/scheduler.rs
index 1e9ad421..aab0fe7b 100644
--- a/crates/ollaya-server/src/scheduler.rs
+++ b/crates/ollaya-server/src/scheduler.rs
@@ -504,6 +504,9 @@ impl Scheduler {
                 if let Some(mmproj) = &f.mmproj {
                     cmd.arg("--mmproj").arg(mmproj);
                 }
+                if let Some(tokenizer) = &f.tokenizer {
+                    cmd.arg("--tokenizer").arg(tokenizer);
+                }
                 cmd.arg("--gguf")
                     .arg(&f.gguf)
                     .arg("--decision")
diff --git a/docs/families/jev-style.md b/docs/families/jev-style.md
new file mode 100644
index 00000000..53f30547
--- /dev/null
+++ b/docs/families/jev-style.md
@@ -0,0 +1,177 @@
+# jev-style (`jev-style-v1`)
+
+**chaoliangUNSW/Jev-Style-2B-Decision-v3** is a Qwen3.5-2B fine-tune (Apache-2.0), a non-generative
+typed-decision model. Unlike `jevk5` / `llm-logits`, it is **not** a last-token label-logit readout:
+it uses a plain-text "render v2" input (no chat template, no system prompt, no answer letters) and a
+**verdict readout** — `logit(" yes") - logit(" no")` at a per-option ` ->` slot — read under
+**non-causal block attention**. The author ships its own GGUF scorer (`jev-score-v2`); this family
+reproduces that scorer on Ollaya's llama.cpp runner. The author publishes GGUF builds in
+**chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF**. Ollaya ships the Q8_0 file as `jev-style:2b` (also
+`jev-style:latest`) and the Q4_K_M file as `jev-style:2b-q4_k_m`.
+
+| | |
+|---|---|
+| Repo / commit | `chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF@283b9eb7903aeb184b16d49ab8f38b256f4afcb3` |
+| Files | `Jev-Style-2B-Decision-v3-Q8_0.gguf` 2.01 GB, sha256 `f4826516125022362f4617e16d28b0e5f95b10d053bac18b59f49f27c89c83bb` (`2b`); `Jev-Style-2B-Decision-v3-Q4_K_M.gguf` 1.27 GB, sha256 `a0140af1710ccff8c00e7e911b1ec0697467a023fcdb3ffde6408dd474d5e124` (`2b-q4_k_m`); both as the repo's `manifest.json` lists them |
+| Tokenizer | the author's `tokenizer/tokenizer.json` from the same commit, sha256 `06b9509352d2af50381ab2247e083b80d32d5c0aba91c272ca9ff729b6a0e523` (`readout_config.json` `tokenizer_sha256`), shipped as the package's tokenizer layer |
+| Source model | `chaoliangUNSW/Jev-Style-2B-Decision-v3@ee807b23807f32813a1df33d83be4d276f2f488a` (Qwen3.5-2B fine-tune, Apache-2.0) |
+| Reference | the model's own runtime `jev_style_decision_gguf.py` (shared core) and `jev_score_v2.cpp`, in the GGUF repo |
+| Readout tokens | ` yes` = 9542, ` no` = 874, ` ->` = 1411 (`readout_config.json` `slot_tokens`; checked against the GGUF and the tokenizer at load) |
+| Temperature | one global `0.8278650620942867` (`readout_config.json` `temperatures.global`), applied by Ollaya's calibration like every family |
+| Architecture | `qwen35` (Gated-DeltaNet + attention); block-causal in the 6 full-attention layers |
+
+**Why Q8_0 is `2b`.** The author's card puts Q8_0 at 99.7 % top-1 agreement with the PyTorch fp32
+reference (1,000 rows) and 43/43 on its long fixture, and Q4_K_M at 95.7 % and 42/43, "noticeably noisier
+on long inputs". Q4_K_M is the smaller download (1.27 GB against 2.01 GB).
+
+## Engine: non-causal block attention on llama.cpp
+
+Where `jevk5`/`llm-logits` read a single causal context, jev-style needs the non-causal, block-wise
+decode its scorer uses. The context is jev-score-v2's (`decision.json` `llama`, checked at load):
+
+- **One non-causal context.** `attention_type = LLAMA_ATTENTION_TYPE_NON_CAUSAL`, `n_ctx = 32768`,
+  `n_batch = n_ubatch = 2048`, `n_seq_max = 2`, `kv_unified = true` and 512 output slots, never toggled:
+  a non-causal ubatch sees all earlier cache cells of its sequence plus itself, with no causal mask inside
+  the block — the block-causal layout of training. The Gated-DeltaNet layers stay recurrent. A
+  `decision.json` with another attention type, an `n_ubatch` below 2048 or fewer than 2 sequences is
+  refused at load (each would score wrongly or trip a llama.cpp assert).
+- **Flash attention** as jev-score-v2 sets it: off on the CPU (the author measured a precision loss there),
+  llama.cpp's auto on a GPU.
+- **One decode per renderer block** (never merged, never re-split), each `<= n_ubatch`.
+- **State computed once.** The state decodes into sequence 0 once; each question does
+  `seq_cp(0 -> 1)`, decodes its question-side block(s) into sequence 1 with logits requested **only**
+  at the ` ->` slots, reads `logit(" yes") - logit(" no")` at each, then `seq_rm(1)`. With the unified
+  cache, `seq_cp` only tags the existing cells, so a question costs its own tokens.
+- **Non-finite scores** (NaN or infinite) are an error, never probabilities, as in the author's runtime.
+
+See [llm-logits.md](llm-logits.md) for the shared llama.cpp runtime and
+[decisions/0003-llama-cpp-runtime.md](../decisions/0003-llama-cpp-runtime.md).
+
+## Tokenizer
+
+The render is tokenised with the author's `tokenizer.json` (Hugging Face `tokenizers` 0.23.2, the
+version the author pins), not with the GGUF's vocabulary: llama.cpp's Qwen3.5 pre-tokenizer splits
+some scripts differently (the shared set's Hindi state is 26 tokens with llama.cpp's and 40 with the
+author's tokenizer), and the model was trained and measured on the author's tokenisation. As in the
+author's `TextEncoder`: no BOS/EOS, and special tokens in user text are split, so `<|im_end|>` in a state
+is text. The GGUF's vocabulary only indexes the logits; the readout tokens are checked in both.
+
+## Prompt (render v2, port of `jev_style_decision_gguf.py`)
+
+```text
+state prefix   State:\n<state>\n\n
+short form     Question [<type>]: <question>\nOptions:\n
+(q+opts+slots   - <option 1> ->\n ... - <option K> ->\n
+ <= 2048 tok)
+overflow form  Question [<type>]: <question>\nOptions:\n
+(otherwise)    Option 1: <option 1>\n ... Option K: <option K>\n            (the catalogue)
+               Judge each numbered option in the complete catalogue above:\n
+               Option 1 ->\n ... Option K ->\n                               (the rubric)
+```
+
+- `<type>` is `choice`, `score` or `noul`. The state is `json.dumps`ed (`ensure_ascii=False`) unless
+  it is already a string. Option bodies (`render_options`): choice `"{name}"` or `"{name}: {desc}"`;
+  score `"level {i}: {desc}"`; noul `"false: …"` / `"true: …"` (default
+  `"no, the statement does not hold"` / `"yes, the statement holds"`).
+- Questions go through Ollaya's shared parser, so a choice given as a list of labels (duplicates
+  collapse onto their first position) and noul keys in any case (`"True"`) are accepted as for every
+  other family; the author's `make_question` takes a list of labels too.
+- Attention blocks: the state is cut into 2,048-token blocks; the short form is one block; in the
+  overflow form the catalogue and the rubric are each cut into 2,048-token blocks.
+
+## Score and probabilities
+
+Option `k`'s score is `logit(" yes") - logit(" no")` at its ` ->` slot, in float32. Probabilities are
+`softmax(scores / T)` in canonical option order (choice: criteria keys; score: levels; noul:
+`false, true`), with the one global temperature — applied by Ollaya's calibration, as for every
+family, so `calibration.json` carries `T` once per type.
+
+## Reference implementation
+
+- `crates/ollaya-decision/src/jev_style.rs` ports the render v2 layout, verdict slots and blocks;
+  `crates/ollaya-runner/src/llama/mod.rs` `run_jev_style` ports the block decode and readout of
+  `jev_score_v2.cpp`.
+- `convert/ollaya_convert/families/jev_style/ref.py` is the Python port of the render.
+  `convert/tests/test_jev_style_render.py` renders the shared set and this layout's own cases with it and
+  with the author's `Renderer` on the pinned `tokenizer.json`: identical ids, slots, blocks and option
+  names, including the overflow form and both budget edges.
+- `convert/ollaya_convert/families/jev_style/goldens.py` writes the goldens: the author's `Renderer`, scored
+  by the author's `jev_score_v2.cpp`, unchanged, compiled against the b11146 headers and linked to
+  ggml-org's stock b11146 release libraries, the ones the runner loads (`load_backends.c` loads their CPU
+  backend variants before `main`, which those builds need). ADR 0003: a `seq_cp` split needs its own
+  reference, and this is it.
+
+## Parity
+
+Goldens: `goldens.py` on Ollaya's shared request set (121 requests) plus this layout's own cases: a state
+of several attention blocks (6,214 tokens), a catalogue overflow of 150 options, and inputs of exactly
+25,600 and 25,601 tokens. A rejected request is followed by its `#valid` questions. The gate,
+`parity_jev_style`, requires identical token ids, verdict slots, attention blocks and option names, every
+decision the same and every verdict score within 1e-3 of jev-score-v2's.
+
+Measured with `parity_run` on 2026-10-26: the CPU on `community-epyc-milan` (an AMD EPYC Milan cloud VM,
+8 vCPUs, the AVX2 CPU backend of the b11146 libraries), Ollaya at `cf1fa64`
+(`results/runs/2026-10-26-parity-communityepycmilan-cpu.json`); CUDA on `rtx-5090` (the CUDA 13.4 backend of
+the b11146 libraries, goldens from jev-score-v2 on the same GPU), Ollaya at `ece7118`
+(`results/runs/2026-10-26-parity-rtx5090-cuda.json`):
+
+| Tag | File | Device | Questions | Decisions | Verdict scores max | Probabilities max |
+|---|---|---|---|---|---|---|
+| `2b` | Q8_0 | CPU (x86-64) | 582 | 582/582 | 4.4e-16 | 0 |
+| `2b-q4_k_m` | Q4_K_M | CPU (x86-64) | 582 | 582/582 | 4.4e-16 | 0 |
+| `2b` | Q8_0 | CUDA (RTX 5090) | 582 | 582/582 | 4.4e-16 | 0 |
+| `2b-q4_k_m` | Q4_K_M | CUDA (RTX 5090) | 582 | 582/582 | 4.4e-16 | 0 |
+
+- **Identical encodings.** 141 records: 124 scored requests, 582 questions, among them 2 in the overflow
+  form (up to 150 options), 4 with a state of several blocks, and one input of exactly 25,600 tokens.
+- **Rejected by both (17).** 13 edge cases whose structured `instructions` the author's runtime refuses,
+  3 decoder cases whose score legend is an object, and the 25,601-token input.
+- **Same scores.** On the same libraries and device the runner's scores are jev-score-v2's to the last
+  bit; the 4.4e-16 is the float64 rounding of the stored scores.
+- **Not run yet.** Metal and Windows; latency.
+
+What the files are worth against the author's PyTorch fp32 reference is the author's measurement (the
+GGUF card, 1,000 development rows): Q8_0 99.7 % top-1 agreement, maximum |Δp| 0.033, 43/43 on the long
+fixture; Q4_K_M 95.7 %, 0.346, 42/43.
+
+## Limits
+
+- **Context.** The complete input (state + question + options + readout) is at most **25,600** tokens;
+  a longer request is rejected (400), never truncated.
+- **Score levels.** A score question takes 2 to 10 levels (the author's limit); other counts are a 400.
+- **Instructions.** A question's `instructions` must be a non-empty string (the author's limit); the
+  structured instructions other families `json.dumps` are a 400 here.
+- **Options.** No option cap: more options than fit one 2,048-token block switch to the catalogue form.
+- **Cost.** The state is decoded once per request; each question then costs only its own tokens.
+- **Runtime.** Stock llama.cpp, Ollama or LM Studio can load the GGUF but would decode causally and cannot
+  produce these scores; the decisions need this engine (or the author's runtime).
+
+## Training data
+
+From the author's [model card](https://huggingface.co/chaoliangUNSW/Jev-Style-2B-Decision-v3) ("Training",
+"Training data and licences"), at the commit above:
+
+- **Base and run.** Qwen/Qwen3.5-2B (revision `15852e8c`) with the vision tower and multi-token-prediction
+  head removed; a full fine-tune of one epoch, 458 steps, 60,032,377 tokens (181,449 rows), a reduced data
+  pool, not the planned full recipe. EMA weights, chosen by a pre-declared rule; one global temperature
+  fitted on 2,000 separate calibration rows.
+- **Mixture.** 58 sources; 77.7 % of the tokens English and 17.0 % Chinese (MASSIVE adds nine more
+  languages). The largest components: model-written typed-decision workflows (34,008 rows, 19.2 %),
+  intents and yes/no QA (MASSIVE, CLINC150, BoolQ), knowledge and reasoning (ARC, CommonsenseQA, MedMCQA,
+  GSM8K, MBPP and others), and jailbreak and prompt-injection sets.
+- **Not zero-shot on 14 benchmarks.** The pool has the train splits of BANKING77, CLINC150 (+OOS), SGD,
+  HellaSwag, GSM8K, ARC-Easy and ARC-Challenge, and format-imitating data for SATA-Bench, BRIGHT, NLI4CT,
+  CRUXEval, CLadder, PhishNChips and BBH. No test split was used; JevBench, tweet_topic, fin_topic and
+  daily_dialog are evaluation-only.
+- **Restrictive or unclear terms**, kept in the pool: research-only jailbreak prompts (the jailbreak_llms
+  collection, jackhhao/jailbreak-classification), HellaSwag (its original repository is blocked after a
+  DMCA notice; only ActivityNet-caption items were used), and share-alike sources (CC BY-SA: SQuAD v2,
+  BoolQ, DROP, SNLI, ARC, SGD, ShARC, TempReason).
+- **Outputs of other models.** OpenAI GPT and Anthropic Claude models designed the typed-decision
+  workflows and Claude models labelled them; a Claude model wrote 1,243 jailbreak and toxicity prompts;
+  GPT models wrote two hard-case families and paraphrased Mac goal items; WANLI, GPTeacher and HelpSteer2
+  carry model-written text. The card notes that the providers' terms may restrict how models trained on
+  such outputs are used. No Jev or other TypeSafe outputs were used.
+
+Ollaya does not redistribute the GGUF or the tokenizer; both are fetched from the author's repository at
+the pinned commit.
diff --git a/results/machines.json b/results/machines.json
index dbeac806..6fc8b85d 100644
--- a/results/machines.json
+++ b/results/machines.json
@@ -75,5 +75,16 @@
   "source": "https://github.com/ollaya-dev/ollaya/pull/33",
   "kind": "community",
   "headline": "RX 9070"
+ },
+ "community-epyc-milan": {
+  "label": "AMD EPYC Milan cloud VM, 8 vCPUs (community)",
+  "cpu": "AMD EPYC (Milan), 8 vCPUs under KVM",
+  "gpus": [],
+  "ram_gb": 16,
+  "os": "Ubuntu 26.04",
+  "by": "mirfan-cof",
+  "source": "https://github.com/ollaya-dev/ollaya/pull/77",
+  "kind": "community",
+  "headline": "EPYC Milan VM"
  }
 }
\ No newline at end of file
diff --git a/results/runs/2026-10-26-parity-communityepycmilan-cpu.json b/results/runs/2026-10-26-parity-communityepycmilan-cpu.json
new file mode 100644
index 00000000..5086ccbd
--- /dev/null
+++ b/results/runs/2026-10-26-parity-communityepycmilan-cpu.json
@@ -0,0 +1,41 @@
+{
+ "schema": 1,
+ "suite": "parity",
+ "date": "2026-10-26",
+ "machine": "community-epyc-milan",
+ "device": "cpu",
+ "ollaya": "0.18.0 at cf1fa64",
+ "protocol": {
+  "reference": "goldens from each family's goldens.py: the authors' code in PyTorch fp32 (TF32 off) on the checkpoint the manifest names",
+  "gate": "fp32 tags: identical encodings and decisions, option logits within 1e-3, wire answers as the authors' code; -fp16 tags (docs/decisions/0008-fp16-decoder-tags.md): identical encodings, at least 99.5 % of decisions the same, differences reported",
+  "runner": "convert/ollaya_convert/parity_run.py with crates/ollaya-runner/examples/parity_<family>.rs"
+ },
+ "results": [
+  {
+   "model": "jev-style:2b",
+   "questions": 582,
+   "decisions_same": 582,
+   "max_logit_diff": 4.440892098500626e-16,
+   "max_prob_diff": 0.0,
+   "p99_prob_diff": 0.0,
+   "pass": true,
+   "device": "cpu",
+   "kind": "runtime",
+   "gate": "fp32",
+   "export_sha256": "f4826516125022362f4617e16d28b0e5f95b10d053bac18b59f49f27c89c83bb"
+  },
+  {
+   "model": "jev-style:2b-q4_k_m",
+   "questions": 582,
+   "decisions_same": 582,
+   "max_logit_diff": 4.440892098500626e-16,
+   "max_prob_diff": 0.0,
+   "p99_prob_diff": 0.0,
+   "pass": true,
+   "device": "cpu",
+   "kind": "runtime",
+   "gate": "fp32",
+   "export_sha256": "a0140af1710ccff8c00e7e911b1ec0697467a023fcdb3ffde6408dd474d5e124"
+  }
+ ]
+}
diff --git a/results/runs/2026-10-26-parity-rtx5090-cuda.json b/results/runs/2026-10-26-parity-rtx5090-cuda.json
new file mode 100644
index 00000000..e54e44b6
--- /dev/null
+++ b/results/runs/2026-10-26-parity-rtx5090-cuda.json
@@ -0,0 +1,41 @@
+{
+ "schema": 1,
+ "suite": "parity",
+ "date": "2026-10-26",
+ "machine": "rtx-5090",
+ "device": "cuda",
+ "ollaya": "0.18.0 at ece7118",
+ "protocol": {
+  "reference": "goldens from each family's goldens.py: the authors' code in PyTorch fp32 (TF32 off) on the checkpoint the manifest names",
+  "gate": "fp32 tags: identical encodings and decisions, option logits within 1e-3, wire answers as the authors' code; -fp16 tags (docs/decisions/0008-fp16-decoder-tags.md): identical encodings, at least 99.5 % of decisions the same, differences reported",
+  "runner": "convert/ollaya_convert/parity_run.py with crates/ollaya-runner/examples/parity_<family>.rs"
+ },
+ "results": [
+  {
+   "model": "jev-style:2b",
+   "questions": 582,
+   "decisions_same": 582,
+   "max_logit_diff": 4.440892098500626e-16,
+   "max_prob_diff": 0.0,
+   "p99_prob_diff": 0.0,
+   "pass": true,
+   "device": "cuda",
+   "kind": "runtime",
+   "gate": "fp32",
+   "export_sha256": "f4826516125022362f4617e16d28b0e5f95b10d053bac18b59f49f27c89c83bb"
+  },
+  {
+   "model": "jev-style:2b-q4_k_m",
+   "questions": 582,
+   "decisions_same": 582,
+   "max_logit_diff": 4.440892098500626e-16,
+   "max_prob_diff": 0.0,
+   "p99_prob_diff": 0.0,
+   "pass": true,
+   "device": "cuda",
+   "kind": "runtime",
+   "gate": "fp32",
+   "export_sha256": "a0140af1710ccff8c00e7e911b1ec0697467a023fcdb3ffde6408dd474d5e124"
+  }
+ ]
+}