From 88d939f1fd9fdc725ec1ab20532a8fc145adebc2 Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Wed, 14 Oct 2026 12:48:26 +0500
Subject: [PATCH 01/11] jev-style: render-v2 decision layout (prompt + verdict
 slots)

Port of Jev-Style-2B-Decision-v3's macjev-render-v2-long-options input and
verdict-slot layout from the model's own jev_style_decision_gguf.py shared core:
State/Question/Options render, short + overflow (catalogue+rubric) forms, the
per-option " ->" slots, 2048-token attention blocks, and softmax(scores/T).
Unit-tested against the reference render. Engine decode wired in a follow-up.

Refs ollaya-dev/ollaya#76
---
 crates/ollaya-decision/src/jev_style.rs | 451 ++++++++++++++++++++++++
 crates/ollaya-decision/src/lib.rs       |   1 +
 2 files changed, 452 insertions(+)
 create mode 100644 crates/ollaya-decision/src/jev_style.rs

diff --git a/crates/ollaya-decision/src/jev_style.rs b/crates/ollaya-decision/src/jev_style.rs
new file mode 100644
index 00000000..045215b4
--- /dev/null
+++ b/crates/ollaya-decision/src/jev_style.rs
@@ -0,0 +1,451 @@
+//! `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::QType;
+
+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,
+    /// `temperatures.global`; `softmax(scores / temperature)`.
+    pub temperature: f64,
+}
+
+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
+            )));
+        }
+        if !(self.temperature.is_finite() && self.temperature > 0.0) {
+            return Err(Error::invalid(format!(
+                "decision.json: temperature must be finite and > 0, got {}",
+                self.temperature
+            )));
+        }
+        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),
+    }
+}
+
+/// `_criterion`: a string verbatim; any other JSON value as `json.dumps(v, ensure_ascii=False)`
+/// (default separators `", "` / `": "`).
+fn criterion(value: &Value) -> String {
+    match value {
+        Value::String(s) => s.clone(),
+        v => crate::pyjson::dumps(v, false),
+    }
+}
+
+/// The option identifiers in canonical (probability) order, validating the question.
+pub fn option_names(qid: &str, qtype: QType, crit: &Value) -> Result<Vec<String>, Error> {
+    let bad = |m: &str| Error::invalid(format!("question {qid:?}: {m}"));
+    match qtype {
+        QType::Choice => match crit {
+            Value::Object(m) if !m.is_empty() => Ok(m.keys().cloned().collect()),
+            _ => Err(bad("choice needs a non-empty object {option name: description or null}")),
+        },
+        QType::Score => match crit {
+            Value::Array(levels) if (2..=10).contains(&levels.len()) => {
+                Ok((0..levels.len()).map(|i| i.to_string()).collect())
+            }
+            _ => Err(bad("score needs a list of 2..10 level descriptions")),
+        },
+        QType::Noul => match crit {
+            Value::Null | Value::Object(_) => Ok(vec!["false".into(), "true".into()]),
+            _ => Err(bad("noul criteria must be null or an object {'false': ..., 'true': ...}")),
+        },
+    }
+}
+
+/// The option bodies in canonical order (`render_options`), without the `- ` / ` ->` wrapping.
+pub fn render_options(qtype: QType, crit: &Value) -> Vec<String> {
+    match qtype {
+        QType::Choice => {
+            let Value::Object(m) = crit else { return Vec::new() };
+            m.iter()
+                .map(|(k, v)| {
+                    if v.is_null() || v == &Value::String(String::new()) {
+                        k.clone()
+                    } else {
+                        format!("{k}: {}", criterion(v))
+                    }
+                })
+                .collect()
+        }
+        QType::Score => {
+            let Value::Array(levels) = crit else { return Vec::new() };
+            levels
+                .iter()
+                .enumerate()
+                .map(|(i, c)| format!("level {i}: {}", criterion(c)))
+                .collect()
+        }
+        QType::Noul => {
+            let empty = serde_json::Map::new();
+            let m = crit.as_object().unwrap_or(&empty);
+            let body = |k: &str, default: &str| {
+                let text = match m.get(k) {
+                    Some(v) if !(v.is_null() || v == &Value::String(String::new())) => criterion(v),
+                    _ => default.to_owned(),
+                };
+                format!("{k}: {text}")
+            };
+            vec![
+                body("false", "no, the statement does not hold"),
+                body("true", "yes, the statement holds"),
+            ]
+        }
+    }
+}
+
+/// `[(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,
+        def: &Value,
+        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}")));
+        let def = def
+            .as_object()
+            .ok_or_else(|| bad("invalid named question".into()))?;
+        let qtype = match def.get("type").and_then(Value::as_str) {
+            Some("choice") => QType::Choice,
+            Some("score") => QType::Score,
+            Some("noul") => QType::Noul,
+            _ => return Err(bad("unknown question type (expected choice, score or noul)".into())),
+        };
+        let ins = match def.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())),
+        };
+        let crit = def.get("criteria").unwrap_or(&Value::Null);
+        let names = option_names(qid, qtype, crit).map_err(E::from)?;
+        let bodies = render_options(qtype, crit);
+
+        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, temperature: 0.8278650620942867 }
+    }
+
+    /// 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();
+        c.render::<Error>(qid, def, &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);
+        }
+    }
+
+    #[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 3fd38484..b2d2e73f 100644
--- a/crates/ollaya-decision/src/lib.rs
+++ b/crates/ollaya-decision/src/lib.rs
@@ -19,6 +19,7 @@ pub mod gliclass;
 pub mod jebadiah;
 pub mod jeeves;
 pub mod jevk5;
+pub mod jev_style;
 pub mod kev;
 pub mod layout;
 pub mod llm_logits;

From 1b0fa07e6564990e4b1c3f15550c5afa54533896 Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Wed, 14 Oct 2026 13:06:18 +0500
Subject: [PATCH 02/11] jev-style: non-causal block-attention engine path

Add the engine half of the jev-style family to the llama runner:
- FFI bindings llama_memory_seq_cp and llama_synchronize;
- data-driven context params (attention_type, n_ubatch, n_seq_max, n_outputs_max)
  on LlamaSettings so a jev-style model loads a non-causal, 2048-ubatch, 2-seq
  context with n_outputs_max slots;
- Layout::JevStyle, its prepare arm (validating the yes/no/arrow readout tokens
  against the GGUF), and run_jev_style: decode the state into sequence 0 once,
  then per question seq_cp 0->1, decode its blocks into sequence 1 reading logits
  only at the verdict slots, score = logit(yes) - logit(no), seq_rm(1). The global
  temperature is applied by the existing calibration layer.

Builds; render layer unit tests pass. Refs ollaya-dev/ollaya#76
---
 crates/ollaya-decision/src/jev_style.rs |  10 +-
 crates/ollaya-runner/src/llama/ffi.rs   |   4 +
 crates/ollaya-runner/src/llama/mod.rs   | 193 +++++++++++++++++++++++-
 3 files changed, 196 insertions(+), 11 deletions(-)

diff --git a/crates/ollaya-decision/src/jev_style.rs b/crates/ollaya-decision/src/jev_style.rs
index 045215b4..36cdb67b 100644
--- a/crates/ollaya-decision/src/jev_style.rs
+++ b/crates/ollaya-decision/src/jev_style.rs
@@ -54,8 +54,6 @@ pub struct JevStyleConfig {
     pub no: u32,
     /// ` ->` verdict-slot token id (1411).
     pub arrow: u32,
-    /// `temperatures.global`; `softmax(scores / temperature)`.
-    pub temperature: f64,
 }
 
 impl JevStyleConfig {
@@ -66,12 +64,6 @@ impl JevStyleConfig {
                 self.layout
             )));
         }
-        if !(self.temperature.is_finite() && self.temperature > 0.0) {
-            return Err(Error::invalid(format!(
-                "decision.json: temperature must be finite and > 0, got {}",
-                self.temperature
-            )));
-        }
         Ok(())
     }
 }
@@ -329,7 +321,7 @@ mod tests {
     const ARROW: u32 = 1411;
 
     fn config() -> JevStyleConfig {
-        JevStyleConfig { layout: LAYOUT.into(), yes: 9542, no: 874, arrow: ARROW, temperature: 0.8278650620942867 }
+        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
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 cd2bd566..1fe2f1e9 100644
--- a/crates/ollaya-runner/src/llama/mod.rs
+++ b/crates/ollaya-runner/src/llama/mod.rs
@@ -30,6 +30,7 @@ use ollaya_decision::cygnet::{self, CygnetConfig};
 use ollaya_decision::d1::{self, D1Config};
 use ollaya_decision::jebadiah::{self, JebadiahConfig};
 use ollaya_decision::jevk5::{self, JevK5Config};
+use ollaya_decision::jev_style::{self, JevStyleConfig};
 use ollaya_decision::llm_logits::{self, LlmLogitsConfig};
 use ollaya_decision::snap::{self, SnapConfig};
 use ollaya_decision::winnow::{self, WinnowConfig};
@@ -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,27 @@ 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,
+}
+
+fn attn_causal() -> i32 {
+    -1
+}
+
+fn ubatch_default() -> u32 {
+    512
+}
+
+fn nseq_default() -> u32 {
+    1
 }
 
 fn prefix_plan() -> String {
@@ -121,6 +144,7 @@ enum Layout {
     },
     Winnow(WinnowConfig),
     JevK5(JevK5Config),
+    JevStyle(JevStyleConfig),
     Jebadiah(JebadiahConfig),
     Cygnet {
         cfg: Box<CygnetConfig>,
@@ -551,6 +575,21 @@ 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}]"
+                    )));
+                }
+            }
+            Layout::JevStyle(cfg)
+        }
         Some(jebadiah::LAYOUT) => {
             let cfg: JebadiahConfig =
                 serde_json::from_value(decision.clone()).map_err(parse_error)?;
@@ -615,6 +654,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],
@@ -633,6 +673,146 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
 }
 
 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 qmap = questions
+            .as_object()
+            .filter(|m| !m.is_empty())
+            .ok_or_else(|| model_error("questions must contain at least one named question"))?;
+        let vocab = &self.vocab;
+        let mut tok = |t: &str| {
+            vocab
+                .tokenize(t, false, false)
+                .map(|v| v.into_iter().map(|x| x as u32).collect::<Vec<u32>>())
+        };
+        let prefix = cfg.state_prefix(state, &mut tok)?;
+        let rendered: Vec<(&String, jev_style::Rendered)> = qmap
+            .iter()
+            .map(|(qid, def)| Ok((qid, cfg.render::<Error>(qid, def, &prefix, &mut tok)?)))
+            .collect::<Result<_, Error>>()?;
+
+        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) };
+            out.push(QuestionOutput {
+                logits: scores,
+                act_logits: None,
+            });
+        }
+        Ok(Output {
+            questions: out,
+            input_tokens,
+            state_tokens: prefix.len(),
+            state_truncated: false,
+        })
+    }
+
+    /// 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,
+        ids: &[u32],
+        lo: usize,
+        hi: usize,
+        pos0: usize,
+        seq: ffi::SeqId,
+        want: &[usize],
+    ) -> Result<Vec<(usize, i32)>, Error> {
+        let n = hi - lo;
+        if n == 0 || n > jev_style::BLOCK {
+            return Err(model_error("jev-style: block length out of range"));
+        }
+        let mut token: Vec<Token> = ids[lo..hi].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,
@@ -989,6 +1169,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,
@@ -1430,6 +1613,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 {
@@ -1481,8 +1667,11 @@ 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);
         cp.n_threads = threads;
         cp.n_threads_batch = threads;
         cp.swa_full = settings.swa_full;

From 1eaae1658bd821e30da1ae73c040ef873dc941af Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Wed, 14 Oct 2026 13:13:34 +0500
Subject: [PATCH 03/11] docs: jev-style family (render v2, non-causal verdict
 readout)

Refs ollaya-dev/ollaya#76
---
 docs/families/jev-style.md | 74 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 docs/families/jev-style.md

diff --git a/docs/families/jev-style.md b/docs/families/jev-style.md
new file mode 100644
index 00000000..ae29c482
--- /dev/null
+++ b/docs/families/jev-style.md
@@ -0,0 +1,74 @@
+# 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 2B Q4_K_M file as `jev-style:2b`.
+
+| | |
+|---|---|
+| Repo / commit | `chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF@283b9eb7903aeb184b16d49ab8f38b256f4afcb3` |
+| File | `Jev-Style-2B-Decision-v3-Q4_K_M.gguf` 1.27 GB, sha256 `a0140af1710ccff8c00e7e911b1ec0697467a023fcdb3ffde6408dd474d5e124` (`manifest.json`) |
+| Source model | `chaoliangUNSW/Jev-Style-2B-Decision-v3` (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 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 |
+
+## 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:
+
+- **One non-causal context.** The context is created once with
+  `attention_type = LLAMA_ATTENTION_TYPE_NON_CAUSAL`, `n_ubatch = 2048`, `n_seq_max = 2` and
+  `n_outputs_max` slots (`decision.json` `llama`), and is 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.
+- **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)`. One question per
+  decode; the state never re-decodes within a request.
+
+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).
+
+## 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"`).
+- Everything is tokenised with **no BOS/EOS and special tokens split** (never control tokens), so
+  `<|im_end|>` in a state is text.
+- The complete input (state + question + options + readout) must fit **25,600** tokens; nothing is
+  truncated — a longer input is rejected. There is **no option cap** (the short form uses one block;
+  more than one block's worth of options switches to the catalogue + rubric form).
+
+## 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 and verdict slots (unit-tested
+against the reference render); `crates/ollaya-runner/src/llama/mod.rs` `run_jev_style` ports the
+block-decode and readout from `jev_score_v2.cpp`.

From deaec554ec11d51d54ea69b165b2ab50c8ecb72f Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Wed, 14 Oct 2026 13:30:39 +0500
Subject: [PATCH 04/11] jev-style: convert recipe (family ref, exporter,
 catalog entry)

- convert/ollaya_convert/families/jev_style/ref.py: the render-v2 Python reference,
  byte-parity-tested against the model's own jev_style_decision_gguf.py (choice,
  score, noul and the overflow catalogue+rubric form: ids, slots, blocks all match).
- llm_common/export_llama.py: a JevStyle exporter that writes decision.json (layout,
  the yes/no/arrow readout token ids read from the GGUF, and the non-causal llama
  settings via llama_extra) and calibration.json (the one global temperature); the
  causal logit goldens are skipped (jev-style reads verdict slots, which need the
  author's jev-score-v2, not the llama-server plan).
- catalog.py: the jev-style:2b entry (Q4_K_M, repo@283b9eb).

Refs ollaya-dev/ollaya#76
---
 convert/ollaya_convert/catalog.py             |  27 ++++
 .../families/jev_style/__init__.py            |   1 +
 .../ollaya_convert/families/jev_style/ref.py  | 144 ++++++++++++++++++
 .../families/llm_common/export_llama.py       |  41 ++++-
 4 files changed, 211 insertions(+), 2 deletions(-)
 create mode 100644 convert/ollaya_convert/families/jev_style/__init__.py
 create mode 100644 convert/ollaya_convert/families/jev_style/ref.py

diff --git a/convert/ollaya_convert/catalog.py b/convert/ollaya_convert/catalog.py
index c5676ce7..d83d2975 100644
--- a/convert/ollaya_convert/catalog.py
+++ b/convert/ollaya_convert/catalog.py
@@ -699,6 +699,33 @@ 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, Q4_K_M. The GGUF holds the weights, tokenizer and the
+            # readout tokens (' yes' 9542, ' no' 874, ' ->' 1411); jev-score-v2 is reproduced by the runner.
+            "2b": _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 (Qwen3.5-2B fine-tune), Q4_K_M 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.",
+                        "2B", ["en"]),
+        },
+        "aliases": {"latest": "2b"},
+        "parity": "Prompt parity: the render matches the model's own jev_style_decision_gguf.py "
+                  "(ollaya_convert.families.jev_style.ref). Logit parity vs the author's jev-score-v2 is "
+                  "pending (non-causal readout; see the PR).",
+    },
     "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/ref.py b/convert/ollaya_convert/families/jev_style/ref.py
new file mode 100644
index 00000000..5b83632c
--- /dev/null
+++ b/convert/ollaya_convert/families/jev_style/ref.py
@@ -0,0 +1,144 @@
+"""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 not isinstance(crit, dict) or not crit:
+            raise QuestionError("choice needs a non-empty object {option name: description or null}")
+        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":
+        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 = crit or {}
+    false_c, true_c = crit.get("false"), crit.get("true")
+    return ["false: " + (_criterion(false_c) if false_c not in (None, "") else "no, the statement does not hold"),
+            "true: " + (_criterion(true_c) if true_c not in (None, "") else "yes, the statement holds")]
+
+
+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 2e96bb84..d69b59d8 100644
--- a/convert/ollaya_convert/families/llm_common/export_llama.py
+++ b/convert/ollaya_convert/families/llm_common/export_llama.py
@@ -362,6 +362,36 @@ 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 = {"attention_type": 1, "n_ubatch": 2048, "n_seq_max": 2, "n_outputs_max": 512}
+
+    def encode(self, state, questions):
+        raise NotImplementedError("jev-style logit-parity goldens need the author's jev-score-v2")
+
+
 def error_class(layout, lay, state, questions, e):
     if layout == "winnow":
         return winnow_error_class(state, winnow_questions(questions), lay.labels, lay.template)
@@ -396,7 +426,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)
@@ -428,7 +458,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"] = {
@@ -439,6 +470,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:
@@ -457,6 +489,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; logit-parity goldens need the author's jev-score-v2, not the "
+                  "causal llama-server plan." % out)
+            return
 
         plan = FixedPlan(post_to(srv.url))
         n_rows = 0

From dd30df989e1187a04b6656250855db6455738b0d Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Tue, 20 Oct 2026 11:25:02 +0500
Subject: [PATCH 05/11] jev-style: fix CI (rustfmt, clippy too_many_arguments,
 mlx test literal)

- cargo fmt --all (jev_style.rs, ollaya-decision/lib.rs, llama/mod.rs)
- decode_block: merge lo/hi into a Range<usize> so it has 7 arguments,
  not 8, satisfying clippy::too_many_arguments; update both call sites
- llama settings_default test: add the new attention_type / n_ubatch /
  n_seq_max / n_outputs_max fields to the struct literal, which fixes the
  missing-fields error (E0063) when building with the mlx feature
---
 crates/ollaya-decision/src/jev_style.rs | 106 ++++++++++++++++++------
 crates/ollaya-decision/src/lib.rs       |   2 +-
 crates/ollaya-runner/src/llama/mod.rs   |  21 +++--
 3 files changed, 96 insertions(+), 33 deletions(-)

diff --git a/crates/ollaya-decision/src/jev_style.rs b/crates/ollaya-decision/src/jev_style.rs
index 36cdb67b..87262846 100644
--- a/crates/ollaya-decision/src/jev_style.rs
+++ b/crates/ollaya-decision/src/jev_style.rs
@@ -113,7 +113,9 @@ pub fn option_names(qid: &str, qtype: QType, crit: &Value) -> Result<Vec<String>
     match qtype {
         QType::Choice => match crit {
             Value::Object(m) if !m.is_empty() => Ok(m.keys().cloned().collect()),
-            _ => Err(bad("choice needs a non-empty object {option name: description or null}")),
+            _ => Err(bad(
+                "choice needs a non-empty object {option name: description or null}",
+            )),
         },
         QType::Score => match crit {
             Value::Array(levels) if (2..=10).contains(&levels.len()) => {
@@ -123,7 +125,9 @@ pub fn option_names(qid: &str, qtype: QType, crit: &Value) -> Result<Vec<String>
         },
         QType::Noul => match crit {
             Value::Null | Value::Object(_) => Ok(vec!["false".into(), "true".into()]),
-            _ => Err(bad("noul criteria must be null or an object {'false': ..., 'true': ...}")),
+            _ => Err(bad(
+                "noul criteria must be null or an object {'false': ..., 'true': ...}",
+            )),
         },
     }
 }
@@ -132,7 +136,9 @@ pub fn option_names(qid: &str, qtype: QType, crit: &Value) -> Result<Vec<String>
 pub fn render_options(qtype: QType, crit: &Value) -> Vec<String> {
     match qtype {
         QType::Choice => {
-            let Value::Object(m) = crit else { return Vec::new() };
+            let Value::Object(m) = crit else {
+                return Vec::new();
+            };
             m.iter()
                 .map(|(k, v)| {
                     if v.is_null() || v == &Value::String(String::new()) {
@@ -144,7 +150,9 @@ pub fn render_options(qtype: QType, crit: &Value) -> Vec<String> {
                 .collect()
         }
         QType::Score => {
-            let Value::Array(levels) = crit else { return Vec::new() };
+            let Value::Array(levels) = crit else {
+                return Vec::new();
+            };
             levels
                 .iter()
                 .enumerate()
@@ -200,11 +208,19 @@ impl JevStyleConfig {
             Some("choice") => QType::Choice,
             Some("score") => QType::Score,
             Some("noul") => QType::Noul,
-            _ => return Err(bad("unknown question type (expected choice, score or noul)".into())),
+            _ => {
+                return Err(bad(
+                    "unknown question type (expected choice, score or noul)".into(),
+                ));
+            }
         };
         let ins = match def.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())),
+            _ => {
+                return Err(bad(
+                    "question text (instructions) must be a non-empty string".into(),
+                ));
+            }
         };
         let crit = def.get("criteria").unwrap_or(&Value::Null);
         let names = option_names(qid, qtype, crit).map_err(E::from)?;
@@ -251,7 +267,8 @@ impl JevStyleConfig {
                 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 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))?);
@@ -308,7 +325,10 @@ pub fn probabilities(scores: &[f64], temperature: f64) -> Vec<f64> {
         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 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()
 }
@@ -321,7 +341,12 @@ mod tests {
     const ARROW: u32 = 1411;
 
     fn config() -> JevStyleConfig {
-        JevStyleConfig { layout: LAYOUT.into(), yes: 9542, no: 874, arrow: ARROW }
+        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
@@ -343,7 +368,13 @@ mod tests {
 
     fn text_of(ids: &[u32]) -> String {
         ids.iter()
-            .map(|&i| if i == ARROW { " ->".to_string() } else { char::from_u32(i).unwrap().to_string() })
+            .map(|&i| {
+                if i == ARROW {
+                    " ->".to_string()
+                } else {
+                    char::from_u32(i).unwrap().to_string()
+                }
+            })
             .collect()
     }
 
@@ -380,24 +411,38 @@ mod tests {
     #[test]
     fn noul_and_score_bodies_match_reference() {
         let c = config();
-        let n = render(&c, &json!("x"), "q",
-            &json!({"type": "noul", "instructions": "Finished?"}));
+        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"));
+            "- 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]}));
+        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"));
+        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?"}));
+        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"));
     }
 
@@ -406,10 +451,19 @@ mod tests {
         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))
+            .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}));
+        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);
@@ -424,8 +478,12 @@ mod tests {
     #[test]
     fn blocks_tile_the_whole_input() {
         let c = config();
-        let r = render(&c, &json!("hello"), "q",
-            &json!({"type": "noul", "instructions": "ok?"}));
+        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) {
diff --git a/crates/ollaya-decision/src/lib.rs b/crates/ollaya-decision/src/lib.rs
index b2d2e73f..f5b6791e 100644
--- a/crates/ollaya-decision/src/lib.rs
+++ b/crates/ollaya-decision/src/lib.rs
@@ -18,8 +18,8 @@ pub mod decision;
 pub mod gliclass;
 pub mod jebadiah;
 pub mod jeeves;
-pub mod jevk5;
 pub mod jev_style;
+pub mod jevk5;
 pub mod kev;
 pub mod layout;
 pub mod llm_logits;
diff --git a/crates/ollaya-runner/src/llama/mod.rs b/crates/ollaya-runner/src/llama/mod.rs
index 1fe2f1e9..f2365070 100644
--- a/crates/ollaya-runner/src/llama/mod.rs
+++ b/crates/ollaya-runner/src/llama/mod.rs
@@ -29,8 +29,8 @@ 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::jevk5::{self, JevK5Config};
 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};
 use ollaya_decision::winnow::{self, WinnowConfig};
@@ -673,7 +673,6 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
 }
 
 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
@@ -712,7 +711,7 @@ impl LlamaModel {
         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, &[])?;
+            self.decode_block(ctx, &prefix, p..e, p, 0, &[])?;
             p = e;
         }
         // SAFETY: the context is live and locked for the whole request.
@@ -733,7 +732,7 @@ impl LlamaModel {
             }
             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)?;
+                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) };
@@ -773,12 +772,12 @@ impl LlamaModel {
         &self,
         ctx: &mut Context,
         ids: &[u32],
-        lo: usize,
-        hi: usize,
+        range: std::ops::Range<usize>,
         pos0: usize,
         seq: ffi::SeqId,
         want: &[usize],
     ) -> Result<Vec<(usize, i32)>, Error> {
+        let (lo, hi) = (range.start, range.end);
         let n = hi - lo;
         if n == 0 || n > jev_style::BLOCK {
             return Err(model_error("jev-style: block length out of range"));
@@ -809,7 +808,9 @@ impl LlamaModel {
         // 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})")));
+            return Err(model_error(format!(
+                "jev-style: llama_decode failed ({rc})"
+            )));
         }
         Ok(got)
     }
@@ -1837,7 +1838,11 @@ 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,
             }
         );
     }

From 058ae2da2029c518858ad2b6ea15b5bd2107c6c1 Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Tue, 20 Oct 2026 13:24:58 +0500
Subject: [PATCH 06/11] jev-style: address review (context, flash-attn, shared
 parser, guards)

Responds to the review on #77 (items 1-6):

1. decode_block takes the already-sliced block plus its start position
   (6 args, no #[allow]); both call sites pass the slice.
2. Use jev-score-v2's context: a kv_unified LlamaSettings field (true for
   jev-style, so sequence 1 gets the whole context and seq_cp is not a
   full-buffer copy); the JevStyle exporter pins n_ctx 32768 and kv_unified;
   run_jev_style rejects an input larger than the context before decoding
   (a 422, not a 500 from inside llama_decode).
3. Flash attention off on the CPU for the non-causal block model
   (jev-score-v2 measured a precision loss there), auto on a GPU.
4. Validate the context at load: attention_type must be 1 and n_ubatch >=
   2048; decode_block checks each block against the context n_ubatch, not
   the fixed BLOCK.
5. Render from the shared question parser (crate::question::Question), so a
   choice given as a list of labels and case-variant noul keys are accepted
   like the rest of ollaya; the author's limits (2..=10 score levels, a
   non-empty string instruction) stay as 400s. ref.py matches.
6. Reject a non-finite verdict score (NaN or infinite) instead of passing
   it to the calibration.
---
 .../ollaya_convert/families/jev_style/ref.py  |   9 +-
 .../families/llm_common/export_llama.py       |   3 +-
 crates/ollaya-decision/src/jev_style.rs       | 117 ++++--------------
 crates/ollaya-runner/src/llama/mod.rs         |  79 +++++++++---
 4 files changed, 93 insertions(+), 115 deletions(-)

diff --git a/convert/ollaya_convert/families/jev_style/ref.py b/convert/ollaya_convert/families/jev_style/ref.py
index 5b83632c..c9079583 100644
--- a/convert/ollaya_convert/families/jev_style/ref.py
+++ b/convert/ollaya_convert/families/jev_style/ref.py
@@ -48,8 +48,11 @@ def option_names(question):
     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}")
+            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:
@@ -77,10 +80,12 @@ 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 = crit or {}
+    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")]
diff --git a/convert/ollaya_convert/families/llm_common/export_llama.py b/convert/ollaya_convert/families/llm_common/export_llama.py
index d69b59d8..a0b8d92c 100644
--- a/convert/ollaya_convert/families/llm_common/export_llama.py
+++ b/convert/ollaya_convert/families/llm_common/export_llama.py
@@ -386,7 +386,8 @@ def __init__(self, srv, a):
         }
         self.plan = "cold"
         # A non-causal context, logits read at the verdict slots (see run_jev_style).
-        self.llama_extra = {"attention_type": 1, "n_ubatch": 2048, "n_seq_max": 2, "n_outputs_max": 512}
+        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 logit-parity goldens need the author's jev-score-v2")
diff --git a/crates/ollaya-decision/src/jev_style.rs b/crates/ollaya-decision/src/jev_style.rs
index 87262846..9c5069b0 100644
--- a/crates/ollaya-decision/src/jev_style.rs
+++ b/crates/ollaya-decision/src/jev_style.rs
@@ -35,7 +35,7 @@ use serde::Deserialize;
 use serde_json::Value;
 
 use crate::Error;
-use crate::question::QType;
+use crate::question::{Criteria, QType, Question};
 
 pub const LAYOUT: &str = "jev-style-v1";
 /// Attention block size (a processing unit, not a content limit).
@@ -98,82 +98,14 @@ pub fn serialize_state(state: &Value) -> String {
     }
 }
 
-/// `_criterion`: a string verbatim; any other JSON value as `json.dumps(v, ensure_ascii=False)`
-/// (default separators `", "` / `": "`).
-fn criterion(value: &Value) -> String {
-    match value {
-        Value::String(s) => s.clone(),
-        v => crate::pyjson::dumps(v, false),
-    }
-}
-
-/// The option identifiers in canonical (probability) order, validating the question.
-pub fn option_names(qid: &str, qtype: QType, crit: &Value) -> Result<Vec<String>, Error> {
-    let bad = |m: &str| Error::invalid(format!("question {qid:?}: {m}"));
-    match qtype {
-        QType::Choice => match crit {
-            Value::Object(m) if !m.is_empty() => Ok(m.keys().cloned().collect()),
-            _ => Err(bad(
-                "choice needs a non-empty object {option name: description or null}",
-            )),
-        },
-        QType::Score => match crit {
-            Value::Array(levels) if (2..=10).contains(&levels.len()) => {
-                Ok((0..levels.len()).map(|i| i.to_string()).collect())
-            }
-            _ => Err(bad("score needs a list of 2..10 level descriptions")),
-        },
-        QType::Noul => match crit {
-            Value::Null | Value::Object(_) => Ok(vec!["false".into(), "true".into()]),
-            _ => Err(bad(
-                "noul criteria must be null or an object {'false': ..., 'true': ...}",
-            )),
-        },
-    }
-}
-
-/// The option bodies in canonical order (`render_options`), without the `- ` / ` ->` wrapping.
-pub fn render_options(qtype: QType, crit: &Value) -> Vec<String> {
-    match qtype {
-        QType::Choice => {
-            let Value::Object(m) = crit else {
-                return Vec::new();
-            };
-            m.iter()
-                .map(|(k, v)| {
-                    if v.is_null() || v == &Value::String(String::new()) {
-                        k.clone()
-                    } else {
-                        format!("{k}: {}", criterion(v))
-                    }
-                })
-                .collect()
-        }
-        QType::Score => {
-            let Value::Array(levels) = crit else {
-                return Vec::new();
-            };
-            levels
-                .iter()
-                .enumerate()
-                .map(|(i, c)| format!("level {i}: {}", criterion(c)))
-                .collect()
-        }
-        QType::Noul => {
-            let empty = serde_json::Map::new();
-            let m = crit.as_object().unwrap_or(&empty);
-            let body = |k: &str, default: &str| {
-                let text = match m.get(k) {
-                    Some(v) if !(v.is_null() || v == &Value::String(String::new())) => criterion(v),
-                    _ => default.to_owned(),
-                };
-                format!("{k}: {text}")
-            };
-            vec![
-                body("false", "no, the statement does not hold"),
-                body("true", "yes, the statement holds"),
-            ]
-        }
+/// 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()],
     }
 }
 
@@ -196,25 +128,14 @@ impl JevStyleConfig {
     pub fn render<E: From<Error>>(
         &self,
         qid: &str,
-        def: &Value,
+        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}")));
-        let def = def
-            .as_object()
-            .ok_or_else(|| bad("invalid named question".into()))?;
-        let qtype = match def.get("type").and_then(Value::as_str) {
-            Some("choice") => QType::Choice,
-            Some("score") => QType::Score,
-            Some("noul") => QType::Noul,
-            _ => {
-                return Err(bad(
-                    "unknown question type (expected choice, score or noul)".into(),
-                ));
-            }
-        };
-        let ins = match def.get("instructions") {
+        // 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(
@@ -222,9 +143,12 @@ impl JevStyleConfig {
                 ));
             }
         };
-        let crit = def.get("criteria").unwrap_or(&Value::Null);
-        let names = option_names(qid, qtype, crit).map_err(E::from)?;
-        let bodies = render_options(qtype, crit);
+        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
@@ -380,7 +304,8 @@ mod tests {
 
     fn render(c: &JevStyleConfig, state: &Value, qid: &str, def: &Value) -> Rendered {
         let prefix = c.state_prefix(state, tok).unwrap();
-        c.render::<Error>(qid, def, &prefix, tok).unwrap()
+        let q = crate::question::Question::parse(qid, def).unwrap();
+        c.render::<Error>(qid, &q, &prefix, tok).unwrap()
     }
 
     #[test]
diff --git a/crates/ollaya-runner/src/llama/mod.rs b/crates/ollaya-runner/src/llama/mod.rs
index f2365070..40632a7d 100644
--- a/crates/ollaya-runner/src/llama/mod.rs
+++ b/crates/ollaya-runner/src/llama/mod.rs
@@ -77,6 +77,10 @@ pub struct LlamaSettings {
     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 {
@@ -588,6 +592,23 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
                     )));
                 }
             }
+            // 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
+                )));
+            }
             Layout::JevStyle(cfg)
         }
         Some(jebadiah::LAYOUT) => {
@@ -685,10 +706,7 @@ impl LlamaModel {
         cfg: &JevStyleConfig,
     ) -> Result<Output, Error> {
         let api = self.handles.api;
-        let qmap = questions
-            .as_object()
-            .filter(|m| !m.is_empty())
-            .ok_or_else(|| model_error("questions must contain at least one named question"))?;
+        let parsed = ollaya_decision::parse_questions(questions)?;
         let vocab = &self.vocab;
         let mut tok = |t: &str| {
             vocab
@@ -696,10 +714,27 @@ impl LlamaModel {
                 .map(|v| v.into_iter().map(|x| x as u32).collect::<Vec<u32>>())
         };
         let prefix = cfg.state_prefix(state, &mut tok)?;
-        let rendered: Vec<(&String, jev_style::Rendered)> = qmap
+        let rendered: Vec<(&String, jev_style::Rendered)> = parsed
             .iter()
-            .map(|(qid, def)| Ok((qid, cfg.render::<Error>(qid, def, &prefix, &mut tok)?)))
+            .map(|(qid, q)| Ok((qid, cfg.render::<Error>(qid, q, &prefix, &mut tok)?)))
             .collect::<Result<_, Error>>()?;
+        // 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
@@ -711,7 +746,7 @@ impl LlamaModel {
         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, &[])?;
+            self.decode_block(ctx, &prefix[p..e], p, 0, &[])?;
             p = e;
         }
         // SAFETY: the context is live and locked for the whole request.
@@ -732,7 +767,7 @@ impl LlamaModel {
             }
             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)?;
+                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) };
@@ -752,6 +787,11 @@ impl LlamaModel {
             }
             // 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,
@@ -771,18 +811,18 @@ impl LlamaModel {
     fn decode_block(
         &self,
         ctx: &mut Context,
-        ids: &[u32],
-        range: std::ops::Range<usize>,
+        block: &[u32],
         pos0: usize,
         seq: ffi::SeqId,
         want: &[usize],
     ) -> Result<Vec<(usize, i32)>, Error> {
-        let (lo, hi) = (range.start, range.end);
-        let n = hi - lo;
-        if n == 0 || n > jev_style::BLOCK {
-            return Err(model_error("jev-style: block length out of range"));
+        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> = ids[lo..hi].iter().map(|&x| x as Token).collect();
+        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];
@@ -1673,10 +1713,16 @@ fn load_on(
         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() {
@@ -1843,6 +1889,7 @@ mod tests {
                 n_ubatch: 512,
                 n_seq_max: 1,
                 n_outputs_max: 0,
+                kv_unified: false,
             }
         );
     }

From 87b21b4367bbe7d3a67cbb43da2563f336bdb9e3 Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Mon, 26 Oct 2026 08:44:44 +0500
Subject: [PATCH 07/11] jev-style: refuse n_seq_max < 2 at load; tests for the
 shared-parser inputs

Follow-up to the second review on #77:

- Item 4: the prepare arm now also refuses a decision.json whose
  llama.n_seq_max is below 2, next to the attention_type and n_ubatch
  checks. With one sequence, llama_memory_seq_cp(0, 1) trips llama.cpp's
  GGML_ASSERT and aborts the runner.
- Item 5: unit tests for the newly accepted inputs (a choice as a list of
  labels, with duplicates collapsing; mixed-case noul keys) and for the
  author's limits (1 and 11 score levels refused, 2 and 10 accepted;
  object, list, number and blank instructions refused). The same cases and
  expected texts run against ref.py in convert/tests/test_jev_style_ref.py,
  so the two renders stay in step.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 convert/tests/test_jev_style_ref.py     | 70 +++++++++++++++++++++++
 crates/ollaya-decision/src/jev_style.rs | 74 +++++++++++++++++++++++++
 crates/ollaya-runner/src/llama/mod.rs   |  7 +++
 3 files changed, 151 insertions(+)
 create mode 100644 convert/tests/test_jev_style_ref.py

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/crates/ollaya-decision/src/jev_style.rs b/crates/ollaya-decision/src/jev_style.rs
index 9c5069b0..ed7457bd 100644
--- a/crates/ollaya-decision/src/jev_style.rs
+++ b/crates/ollaya-decision/src/jev_style.rs
@@ -417,6 +417,80 @@ mod tests {
         }
     }
 
+    /// 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);
diff --git a/crates/ollaya-runner/src/llama/mod.rs b/crates/ollaya-runner/src/llama/mod.rs
index 40632a7d..65273335 100644
--- a/crates/ollaya-runner/src/llama/mod.rs
+++ b/crates/ollaya-runner/src/llama/mod.rs
@@ -609,6 +609,13 @@ fn prepare(vocab: &Vocab, decision: &Value) -> Result<Layout, Error> {
                     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) => {

From cf1fa64b705e3d2d8ec8281367bf730c30ce3ea4 Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Mon, 26 Oct 2026 10:04:27 +0500
Subject: [PATCH 08/11] jev-style: goldens from jev-score-v2, the parity gate,
 the author's tokenizer, Q8_0 tags

Review items 7-10 on #77:

- goldens.py: the author's Renderer (jev_style_decision_gguf.py) scored by
  jev_score_v2.cpp, unchanged, built against the b11146 headers and linked
  to ggml-org's stock b11146 release libraries (load_backends.c loads their
  CPU backend variants before main). Ollaya's shared request set plus this
  layout's cases: several state blocks, a 150-option catalogue overflow,
  inputs of exactly 25,600 and 25,601 tokens. Per question: ids, slots,
  blocks, [yes, no] logits, scores; one file per device.
- parity_jev_style: identical ids, slots, blocks and option names, every
  decision the same, verdict scores within 1e-3; prints a record: line.
  parity_run records GGUF families listed in GGUF_RECORDED (jev-style),
  and results/machines.json gains the community CPU machine.
- The render now uses the author's tokenizer.json (the package's tokenizer
  layer, passed to the llama runner like --mmproj): llama.cpp's Qwen3.5
  pre-tokenizer splits some scripts differently (the shared set's Hindi
  state is 26 tokens there, 40 with the author's tokenizer).
- convert/tests/test_jev_style_render.py: ref.py against the author's
  Renderer on the pinned tokenizer.json, shared set plus the layout cases.
- Tags: jev-style:2b (and latest) is Q8_0; Q4_K_M is 2b-q4_k_m.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 convert/ollaya_convert/catalog.py             |  29 +-
 .../families/jev_style/goldens.py             | 243 +++++++++++++++
 .../families/jev_style/load_backends.c        |  20 ++
 .../families/llm_common/export_llama.py       |   6 +-
 convert/ollaya_convert/package.py             |   2 +
 convert/ollaya_convert/parity_run.py          |  39 ++-
 convert/tests/test_jev_style_render.py        | 107 +++++++
 .../examples/parity_jev_style.rs              | 286 ++++++++++++++++++
 crates/ollaya-runner/src/llama/mod.rs         |  87 +++++-
 crates/ollaya-runner/src/server.rs            |   3 +
 crates/ollaya-server/src/models.rs            |   6 +
 crates/ollaya-server/src/scheduler.rs         |   3 +
 results/machines.json                         |  11 +
 13 files changed, 811 insertions(+), 31 deletions(-)
 create mode 100644 convert/ollaya_convert/families/jev_style/goldens.py
 create mode 100644 convert/ollaya_convert/families/jev_style/load_backends.c
 create mode 100644 convert/tests/test_jev_style_render.py
 create mode 100644 crates/ollaya-runner/examples/parity_jev_style.rs

diff --git a/convert/ollaya_convert/catalog.py b/convert/ollaya_convert/catalog.py
index 4bc28cbb..09fac57a 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,
     }
 
 
@@ -1041,16 +1043,25 @@ def _kev_license(repo, base):
                         "are the author's.\n"
                         "Licensed under the Apache License, Version 2.0.\n\n" + LICENSE_APACHE,
         "tags": {
-            # Jev-Style-2B-Decision-v3, Q4_K_M. The GGUF holds the weights, tokenizer and the
-            # readout tokens (' yes' 9542, ' no' 874, ' ->' 1411); jev-score-v2 is reproduced by the runner.
-            "2b": _gguf("jev-style-2b-q4_k_m", "chaoliangUNSW/Jev-Style-2B-Decision-v3-GGUF",
+            # 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-Q4_K_M.gguf",
-                        "Jev-Style-2B-Decision-v3 (Qwen3.5-2B fine-tune), Q4_K_M GGUF on llama.cpp: a "
+                        "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.",
-                        "2B", ["en"]),
+                        "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": "Prompt parity: the render matches the model's own jev_style_decision_gguf.py "
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/llm_common/export_llama.py b/convert/ollaya_convert/families/llm_common/export_llama.py
index bfd06aa7..7aa961b5 100644
--- a/convert/ollaya_convert/families/llm_common/export_llama.py
+++ b/convert/ollaya_convert/families/llm_common/export_llama.py
@@ -390,7 +390,7 @@ def __init__(self, srv, a):
                             "n_outputs_max": 512, "kv_unified": True}
 
     def encode(self, state, questions):
-        raise NotImplementedError("jev-style logit-parity goldens need the author's jev-score-v2")
+        raise NotImplementedError("jev-style goldens: python -m ollaya_convert.families.jev_style.goldens")
 
 
 def error_class(layout, lay, state, questions, e):
@@ -486,8 +486,8 @@ def main():
             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; logit-parity goldens need the author's jev-score-v2, not the "
-                  "causal llama-server plan." % out)
+                  "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))
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 b2cf98e2..cd35a90f 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"}
+# 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_render.py b/convert/tests/test_jev_style_render.py
new file mode 100644
index 00000000..4f1e19d2
--- /dev/null
+++ b/convert/tests/test_jev_style_render.py
@@ -0,0 +1,107 @@
+"""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]))
+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
+
+
+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-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/mod.rs b/crates/ollaya-runner/src/llama/mod.rs
index 176c3788..4260197e 100644
--- a/crates/ollaya-runner/src/llama/mod.rs
+++ b/crates/ollaya-runner/src/llama/mod.rs
@@ -238,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`).
@@ -721,6 +724,9 @@ 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
@@ -734,18 +740,7 @@ impl LlamaModel {
         cfg: &JevStyleConfig,
     ) -> Result<Output, Error> {
         let api = self.handles.api;
-        let parsed = ollaya_decision::parse_questions(questions)?;
-        let vocab = &self.vocab;
-        let mut tok = |t: &str| {
-            vocab
-                .tokenize(t, false, false)
-                .map(|v| v.into_iter().map(|x| x as u32).collect::<Vec<u32>>())
-        };
-        let prefix = cfg.state_prefix(state, &mut tok)?;
-        let rendered: Vec<(&String, jev_style::Rendered)> = parsed
-            .iter()
-            .map(|(qid, q)| Ok((qid, cfg.render::<Error>(qid, q, &prefix, &mut tok)?)))
-            .collect::<Result<_, Error>>()?;
+        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 {
@@ -833,6 +828,46 @@ impl LlamaModel {
         })
     }
 
+    /// `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.
@@ -991,6 +1026,7 @@ impl LlamaModel {
             vocab,
             layout,
             settings: d.llama.clone(),
+            tokenizer: None,
             device,
             precision: d.gguf.quantization.clone(),
         };
@@ -998,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,
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/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

From 520d97ee181155f4cc3dd747b321683afbef21a7 Mon Sep 17 00:00:00 2001
From: Muhammad Irfan <MuhammadIrfan@consultancyoutfit.co.uk>
Date: Mon, 26 Oct 2026 11:28:16 +0500
Subject: [PATCH 09/11] jev-style: CPU parity record and docs with the measured
 numbers

Review item 11 on #77, and the stage-2 record for item 8:

- results/runs/2026-10-26-parity-communityepycmilan-cpu.json: parity_run
  on community-epyc-milan, Ollaya at cf1fa64. jev-style:2b (Q8_0) and
  jev-style:2b-q4_k_m: 582 questions each, identical ids/slots/blocks,
  582/582 decisions, verdict scores within 4.4e-16 of jev-score-v2.
- docs/families/jev-style.md: Parity (the numbers above, what the set
  covers, what was rejected and what was not run), the tokenizer, Limits
  (25,600 tokens, 2 to 10 score levels, string instructions) and the
  card's training-data notes.
- catalog.py: the parity text gives the measured numbers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 convert/ollaya_convert/catalog.py             |   8 +-
 docs/families/jev-style.md                    | 138 +++++++++++++++---
 ...6-10-26-parity-communityepycmilan-cpu.json |  41 ++++++
 3 files changed, 164 insertions(+), 23 deletions(-)
 create mode 100644 results/runs/2026-10-26-parity-communityepycmilan-cpu.json

diff --git a/convert/ollaya_convert/catalog.py b/convert/ollaya_convert/catalog.py
index 09fac57a..8770db08 100644
--- a/convert/ollaya_convert/catalog.py
+++ b/convert/ollaya_convert/catalog.py
@@ -1064,9 +1064,11 @@ def _kev_license(repo, base):
                                "2B", ["en"], tokenizer="tokenizer/tokenizer.json"),
         },
         "aliases": {"latest": "2b"},
-        "parity": "Prompt parity: the render matches the model's own jev_style_decision_gguf.py "
-                  "(ollaya_convert.families.jev_style.ref). Logit parity vs the author's jev-score-v2 is "
-                  "pending (non-causal readout; see the PR).",
+        "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, a community machine). The render is identical to the author's "
+                  "jev_style_decision_gguf.py on the author's tokenizer.",
     },
     "decima": {
         "namespace": "library",
diff --git a/docs/families/jev-style.md b/docs/families/jev-style.md
index ae29c482..57d1ccd3 100644
--- a/docs/families/jev-style.md
+++ b/docs/families/jev-style.md
@@ -6,37 +6,56 @@ it uses a plain-text "render v2" input (no chat template, no system prompt, no 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 2B Q4_K_M file as `jev-style:2b`.
+**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` |
-| File | `Jev-Style-2B-Decision-v3-Q4_K_M.gguf` 1.27 GB, sha256 `a0140af1710ccff8c00e7e911b1ec0697467a023fcdb3ffde6408dd474d5e124` (`manifest.json`) |
-| Source model | `chaoliangUNSW/Jev-Style-2B-Decision-v3` (Qwen3.5-2B fine-tune, Apache-2.0) |
+| 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 at load) |
+| 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:
+decode its scorer uses. The context is jev-score-v2's (`decision.json` `llama`, checked at load):
 
-- **One non-causal context.** The context is created once with
-  `attention_type = LLAMA_ATTENTION_TYPE_NON_CAUSAL`, `n_ubatch = 2048`, `n_seq_max = 2` and
-  `n_outputs_max` slots (`decision.json` `llama`), and is 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.
+- **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)`. One question per
-  decode; the state never re-decodes within a request.
+  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
@@ -54,11 +73,11 @@ overflow form  Question [<type>]: <question>\nOptions:\n
   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"`).
-- Everything is tokenised with **no BOS/EOS and special tokens split** (never control tokens), so
-  `<|im_end|>` in a state is text.
-- The complete input (state + question + options + readout) must fit **25,600** tokens; nothing is
-  truncated — a longer input is rejected. There is **no option cap** (the short form uses one block;
-  more than one block's worth of options switches to the catalogue + rubric form).
+- 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
 
@@ -69,6 +88,85 @@ family, so `calibration.json` carries `T` once per type.
 
 ## Reference implementation
 
-`crates/ollaya-decision/src/jev_style.rs` ports the render v2 layout and verdict slots (unit-tested
-against the reference render); `crates/ollaya-runner/src/llama/mod.rs` `run_jev_style` ports the
-block-decode and readout from `jev_score_v2.cpp`.
+- `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 on `community-epyc-milan` (an AMD EPYC Milan cloud VM, 8 vCPUs, the AVX2 CPU backend of the
+b11146 libraries), 2026-10-26, Ollaya at `cf1fa64`, with `parity_run` (`results/runs/2026-10-26-parity-communityepycmilan-cpu.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 |
+
+- **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.** CUDA (the RTX 5090 run before merging), 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/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"
+  }
+ ]
+}

From ece7118081511a32dd00a838a46ce7df568598b7 Mon Sep 17 00:00:00 2001
From: Mert Cobanov <mertcobanov@gmail.com>
Date: Mon, 26 Oct 2026 11:48:10 +0300
Subject: [PATCH 10/11] jev-style: skip the render test without numpy and
 tokenizers

goldens.py imports numpy at module level, so CI's packaging job (no ML dependencies) failed to import the
test module instead of skipping it. Same skipUnless pattern as test_fp16.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nGz6RQQsBfLJAGByzb1Bn
---
 convert/tests/test_jev_style_render.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/convert/tests/test_jev_style_render.py b/convert/tests/test_jev_style_render.py
index 4f1e19d2..d4ccf164 100644
--- a/convert/tests/test_jev_style_render.py
+++ b/convert/tests/test_jev_style_render.py
@@ -17,7 +17,9 @@
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-from ollaya_convert.families.jev_style import goldens, ref
+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/"
@@ -51,6 +53,7 @@ def fetch(name):
     return path
 
 
+@unittest.skipUnless(HAVE_DEPS, "needs the convert environment (numpy, tokenizers)")
 class RenderParity(unittest.TestCase):
     @classmethod
     def setUpClass(cls):

From 67f9605f2546c3fb2bca1afacbd13cf6abfe222b Mon Sep 17 00:00:00 2001
From: Mert Cobanov <mertcobanov@gmail.com>
Date: Mon, 26 Oct 2026 11:56:59 +0300
Subject: [PATCH 11/11] jev-style: CUDA parity on the RTX 5090

Goldens from jev-score-v2 on the same GPU (the CUDA 13.4 backend of the b11146 libraries), then
parity_run --machine rtx-5090 --device cuda: both tags 582/582 decisions, identical encodings and the same
17 rejections, verdict scores bit-identical. The family doc and the catalog's parity text now name both devices.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nGz6RQQsBfLJAGByzb1Bn
---
 convert/ollaya_convert/catalog.py             |  4 +-
 docs/families/jev-style.md                    | 11 +++--
 .../runs/2026-10-26-parity-rtx5090-cuda.json  | 41 +++++++++++++++++++
 3 files changed, 51 insertions(+), 5 deletions(-)
 create mode 100644 results/runs/2026-10-26-parity-rtx5090-cuda.json

diff --git a/convert/ollaya_convert/catalog.py b/convert/ollaya_convert/catalog.py
index 06253086..61381a54 100644
--- a/convert/ollaya_convert/catalog.py
+++ b/convert/ollaya_convert/catalog.py
@@ -1106,8 +1106,8 @@ def _kev_license(repo, base):
         "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, a community machine). The render is identical to the author's "
-                  "jev_style_decision_gguf.py on the author's tokenizer.",
+                  "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",
diff --git a/docs/families/jev-style.md b/docs/families/jev-style.md
index 57d1ccd3..53f30547 100644
--- a/docs/families/jev-style.md
+++ b/docs/families/jev-style.md
@@ -109,13 +109,18 @@ of several attention blocks (6,214 tokens), a catalogue overflow of 150 options,
 `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 on `community-epyc-milan` (an AMD EPYC Milan cloud VM, 8 vCPUs, the AVX2 CPU backend of the
-b11146 libraries), 2026-10-26, Ollaya at `cf1fa64`, with `parity_run` (`results/runs/2026-10-26-parity-communityepycmilan-cpu.json`):
+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.
@@ -123,7 +128,7 @@ b11146 libraries), 2026-10-26, Ollaya at `cf1fa64`, with `parity_run` (`results/
   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.** CUDA (the RTX 5090 run before merging), Metal and Windows; latency.
+- **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
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"
+  }
+ ]
+}