Release nullspan v1.3.0: 395M 8K Tree-Isolated Parallel-Span System One (79.00% Typed Decisions, 0.0760 KL, 0.0420 Brier, 100% JevBench Easy)

.eval_results/typed-decisions.yaml

@@ -1,40 +1,40 @@
 - dataset:
     id: LocalLLaMA/typed-decisions
     task_id: accuracy
-  value: 0.754
-  date: "2026-10-30"
+  value: 0.79
+  date: "2026-10-31"
   source:
     url: https://huggingface.co/datasets/LocalLLaMA/typed-decisions
     name: "Typed Decisions"
     user: gnumanth
-  notes: "Pure non-LLM bidirectional cross-encoder (DeBERTa-v3-Large 435M + LoRA + Cross-Option & Cross-Question Workflow Competition Head, 0 generated output tokens). Fine-tuned on the Typed Decisions train split alongside public BoolQ/ARC-Challenge/SciQ train splits and programmatic System One rubrics; not zero-shot. Official test split (untouched during training & calibration): 400 cases, 2,000 decisions, one /v1/systemone request per case, zero errors."
+  notes: "Pure non-LLM 8K bidirectional encoder (NullspanSystemOneEngine v1.3.0 · 395M ModernBERT-large with Exact Tree-Isolated Parallel-Option Masking, Cross-Question Workflow Competition, and 24 Latent Factor Heads; 1 forward pass per case, 0 generated output tokens, 47.8 ms/case on L4). Mode: specialist (fine-tuned via 10-model 5-fold OOF cross-backbone self-distillation on Typed Decisions train + public BoolQ/ARC/SciQ train splits + programmatic System One rubrics; not zero-shot). Official test split (strictly untouched during training & OOF calibration): 400 cases, 2,000 decisions, zero errors."
 - dataset:
     id: LocalLLaMA/typed-decisions
     task_id: kl_from_gold
-  value: 0.1515
-  date: "2026-10-30"
+  value: 0.076
+  date: "2026-10-31"
   source:
     url: https://huggingface.co/datasets/LocalLLaMA/typed-decisions
     name: "Typed Decisions"
     user: gnumanth
-  notes: "Pure non-LLM bidirectional cross-encoder (0 generated output tokens). Fine-tuned on Typed Decisions train + public train splits; evaluated once on 400 test cases (2,000 decisions)."
+  notes: "Pure non-LLM 395M 8K Tree-Isolated Parallel-Span ModernBERT-large (0 generated output tokens, 1 forward pass per case). Mode: specialist (fine-tuned on Typed Decisions train + public train splits); evaluated once on 400 untouched test cases (2,000 decisions)."
 - dataset:
     id: LocalLLaMA/typed-decisions
     task_id: brier
-  value: 0.077
-  date: "2026-10-30"
+  value: 0.042
+  date: "2026-10-31"
   source:
     url: https://huggingface.co/datasets/LocalLLaMA/typed-decisions
     name: "Typed Decisions"
     user: gnumanth
-  notes: "Pure non-LLM bidirectional cross-encoder (0 generated output tokens). Fine-tuned on Typed Decisions train + public train splits; evaluated once on 400 test cases (2,000 decisions)."
+  notes: "Pure non-LLM 395M 8K Tree-Isolated Parallel-Span ModernBERT-large (0 generated output tokens, 1 forward pass per case). Mode: specialist (fine-tuned on Typed Decisions train + public train splits); evaluated once on 400 untouched test cases (2,000 decisions)."
 - dataset:
     id: LocalLLaMA/typed-decisions
     task_id: ece
-  value: 0.0944
-  date: "2026-10-30"
+  value: 0.1665
+  date: "2026-10-31"
   source:
     url: https://huggingface.co/datasets/LocalLLaMA/typed-decisions
     name: "Typed Decisions"
     user: gnumanth
-  notes: "Pure non-LLM bidirectional cross-encoder (0 generated output tokens). Fine-tuned on Typed Decisions train + public train splits; evaluated once on 400 test cases (2,000 decisions)."
+  notes: "Pure non-LLM 395M 8K Tree-Isolated Parallel-Span ModernBERT-large (0 generated output tokens, 1 forward pass per case). Mode: specialist (fine-tuned on Typed Decisions train + public train splits); evaluated once on 400 untouched test cases (2,000 decisions)."

README.md

@@ -10,7 +10,7 @@ tags:
   - span-extraction
   - calibrated-estimation
   - electra
-  - deberta-v3
+  - modernbert
   - onnx
 datasets:
   - gnumanth/nullspan-dataset
@@ -24,23 +24,23 @@ metrics:
 pipeline_tag: question-answering
 ---
 
-# gnumanth/nullspan (`v1.2.1`)
+# gnumanth/nullspan (`v1.3.0`)
 
-**`nullspan` v1.2.1** ships two zero-output-token **System One** neural models in one open-weights MIT repository:
+**`nullspan` v1.3.0** ships two zero-output-token **System One** neural models in one open-weights MIT repository:
 
 1. **`NullspanForExtraction` (`345.3M` PyTorch FP32 + `331.1 MB` Int8 ONNX, `512`-token context + long-document windowing)**: Grounded `[start, end]` span extraction, calibrated `p_null` abstention (with dedicated `qa_null_head`), multi-numeric contract disambiguation (`96/96`), cross-field algebraic `constraint` verification, and `(p10, median, p90)` quantile estimation.
-2. **`NullspanSystemOneEngine` (`435M` DeBERTa-v3-Large + `r=32` LoRA + Cross-Option & Cross-Question Workflow Competition Head, `systemone/`)**: Native `/v1/systemone` calibrated decision model for `noul` (`true`/`false`), `choice` (`options`), and ordinal `score` (`min..max`) rubrics with `0` generated output tokens.
+2. **`NullspanSystemOneEngine` (`395M` 8K `ModernBERT-large` with Exact Tree-Isolated Parallel-Option Masking + Cross-Question Workflow Competition + 24 Latent Factor Heads, `systemone/`)**: Native `/v1/systemone` calibrated decision model for `noul` (`true`/`false`), `choice` (`options`), and ordinal `score` (`min..max`) rubrics in **a single forward pass per case** (`47.8 ms/case`, `9.56 ms/decision` on L4) with `0` generated output tokens and `0.0` cross-option RoPE bleed (`100%` option-order permutation invariant).
 
 ## Verified Public Benchmark Scores (Google Cloud NVIDIA L4 GPU · Zero Test Contamination)
 
 | Public Benchmark | Dataset & Split | Score | Calibration & Validity | Latency / Cost (L4 GPU) |
 | :--- | :--- | :---: | :---: | :---: |
-| **[`LocalLLaMA/typed-decisions`](https://huggingface.co/datasets/LocalLLaMA/typed-decisions)** | Official `test` (`400` cases · `2,000` decisions) | **`75.40%` Accuracy** (Table 2 fitted cross-encoder; `#2` vs Hub `.eval_results` widget) | `KL 0.1515` · `Brier 0.0770` · `ECE 0.0944` | `78.0 ms/dec` (`390.0 ms/case`) · `0` output tokens |
-| **[Benchmark Heaven / `jevbench`](https://github.com/fstandhartinger/jevbench)** | Official Public Suite (`231` items via `/v1/systemone`) | **`100.0%` Easy (`48/48`)** · `62.50%` Original (`45/72`) · `37.84%` Hard (`42/111`) | **`100.0%` Strict Schema Validity** (`Easy Brier 0.0207`, `ECE 0.0605`) | **`64.8 ms` `p50`** · **`$0.00667 / 1k`** (`encoder_classifier_<=0.6B`) |
-| **[Stanford `rajpurkar/squad_v2`](https://huggingface.co/datasets/rajpurkar/squad_v2)** | Zero-overlap `validation` (`N = 500`: `250` HasAns + `250` NoAns) | **`87.00%` Exact Match** · **`89.36%` F1** | `HasAns F1 91.52%` · `NoAns EM 87.20%` | `10.30 ms` `p50` · `$0.0017 / 1k` |
+| **[`LocalLLaMA/typed-decisions`](https://huggingface.co/datasets/LocalLLaMA/typed-decisions)** | Official `test` (`400` cases · `2,000` decisions) | **`79.00%` Accuracy** (`96.3%` of ~`82.05%` empirical Bayes ceiling; `#1` Hub `.eval_results` widget; beats `Arbiter-4B` `78.6%`, `qwen3.5-27b` `78.3%`, `gpt-5.4` `77.7%`, `SafeDecide-400M` `77.5%`, `TypeSafe Jev` `73.3%`) | **`KL 0.0760` (`#2` worldwide)** · **`Brier 0.0420` (`#1` tied worldwide)** · `ECE 0.1665` | **`9.56 ms/dec` (`47.8 ms/case`)** · `0` output tokens |
+| **[Benchmark Heaven / `jevbench`](https://github.com/fstandhartinger/jevbench)** | Official Public Suite (`231` items via `/v1/systemone`) | **`100.0%` Easy (`48/48`)** · **`68.06%` Original (`49/72`)** · `36.04%` Hard (`40/111`) (`59.31%` all · `v1.3 Geo 46.27`) | **`100.0%` Strict Schema Validity** (`ECE 0.0755`) | **`38.82 ms` `p50`** (`37.76 ms` Easy) · **`$0.00604 / 1k`** (`encoder_classifier_<=0.6B`) |
+| **[Stanford `rajpurkar/squad_v2`](https://huggingface.co/datasets/rajpurkar/squad_v2)** | Zero-overlap `validation` (`N = 500`: `250` HasAns + `250` NoAns) | **`87.80%` Exact Match** · **`90.90%` F1** | `HasAns F1 90.61%` · `NoAns EM 91.20%` | `10.30 ms` `p50` · `$0.0017 / 1k` |
 | **[`NullspanBench v3.2`](https://hemanth.github.io/nullspan/bench.html)** | `N = 500` (`336` Open + `164` Sealed: SQuAD2, `96` Contracts, `8` Adversarial) | **`98.2` Capability** · **`98.0%` Intelligence** (`95.7` Hybrid Composite) | **`98.5` Calibration** (`AUROC 0.9933`, `ECE 0.0142`; Int8 ONNX `ECE 0.0127`) | `10.30 ms` CUDA `p50` (`0.040 ms` Hybrid) · `$0.0003–$0.0017 / 1k` |
 
-> **Training Disclosure**: `NullspanSystemOneEngine` is fine-tuned on the `LocalLLaMA/typed-decisions` `train` split alongside public `BoolQ`, `ARC-Challenge`, and `SciQ` `train` splits plus programmatic synthetic System One rubrics; it is **not zero-shot** on `Typed Decisions`. All test/evaluation splits (`Typed Decisions test`, `JevBench` public & sealed suites, `SQuAD v2.0 validation`, and `NullspanBench` evaluation pools) were strictly untouched during training and post-hoc temperature calibration.
+> **Training Disclosure (`mode: specialist`)**: `NullspanSystemOneEngine` (`v1.3.0`) is trained via Stage 1 general System One pretraining (`BoolQ`, `ARC-Challenge`, `SciQ` `train` splits + programmatic numeric/policy/negation/adequacy rubrics) followed by Stage 2 `10`-model `5`-fold Cross-Backbone OOF Self-Distillation + Trajectory-SWA on the `LocalLLaMA/typed-decisions` `train` split; it is **not zero-shot** on `Typed Decisions`. All test/evaluation splits (`Typed Decisions test`, `JevBench` public & sealed suites, `SQuAD v2.0 validation`, and `NullspanBench` evaluation pools) were strictly untouched during training and OOF calibration. Prior `v1.2.1` weights remain immutably preserved at commit `43cd3a296bbc858189d1e183eaed6e89f95e5dfd`.
 
 ## Quick Start — Grounded Extraction (`NullspanForExtraction`)
 
@@ -95,7 +95,7 @@ print(res["answers"])
 Or serve the TypeSafe-compatible `/v1/systemone` HTTP endpoint directly:
 
 ```bash
-pip install "nullspan[hf]" fastapi uvicorn peft
+pip install "nullspan[hf]" fastapi uvicorn
 python serve_systemone.py --model-dir gnumanth/nullspan --port 8010
 ```
 
@@ -103,7 +103,7 @@ python serve_systemone.py --model-dir gnumanth/nullspan --port 8010
 
 - `model.safetensors`, `config.json`, `modeling_nullspan.py`: `NullspanForExtraction` (`345.3M` ELECTRA-Large + 2-layer Pre-LN `SchemaAdapterBlock` + `qa_null_head`).
 - `onnx/model_quantized.onnx`, `onnx/tokenizer.json`: `331.1 MB` dynamic `QUInt8` ONNX model powering offline Browser WASM (`https://hemanth.github.io/nullspan/`) and CPU inference.
-- `systemone/`, `systemone_decision.pt`, `systemone_decision.py`, `serve_systemone.py`: `NullspanSystemOneEngine` (`435M` DeBERTa-v3-Large + `r=32` LoRA + `CrossOptionDecisionHead` + Cross-Question Workflow Propagation) and `/v1/systemone` FastAPI server.
+- `systemone/`, `systemone_decision.pt`, `systemone_decision.py`, `serve_systemone.py`, `predictions_typed_decisions_test.jsonl`: `NullspanSystemOneEngine` (`395M` 8K `ModernBERT-large` with Exact Tree-Isolated Parallel-Option Masking, `ParallelSpanDecisionHead`, Cross-Question Workflow Competition, and 24 Latent Factor Heads) and `/v1/systemone` FastAPI server.
 - `.eval_results/typed-decisions.yaml`, `.eval_results/nullspan-bench.yaml`, `SCIENCE_REPORT.md`: Reproducible benchmark metadata and statistical report.
 
 ## License

eval_results.json

@@ -0,0 +1,571 @@
+{
+  "repo_id": "gnumanth/nullspan",
+  "backbone": "ahotrod/electra_large_discriminator_squad2_512",
+  "params_m": 344.22,
+  "max_length": 512,
+  "device": "Tesla V100-SXM2-16GB",
+  "train_seconds": 1439.16,
+  "epochs": 8,
+  "train_samples": 8290,
+  "cal_dev_samples": 720,
+  "calibration": {
+    "null_bias_delta": 5.9,
+    "null_temperature": 0.7,
+    "span_temperature": 1.2,
+    "qa_null_bias": 0.0,
+    "qa_null_scale": 0.22
+  },
+  "val_metrics": {
+    "null_accuracy": 96.94,
+    "null_auroc": 0.99273,
+    "null_ece": 0.01553,
+    "null_brier_score": 0.02711,
+    "span_exact_match": 87.82,
+    "op_accuracy": 100.0,
+    "list_bio_token_accuracy": 100.0,
+    "quantile_mae_norm": 0.0007,
+    "quantile_pinball_loss": 0.0001
+  },
+  "canonical_eval": {
+    "canonical_field_accuracy": 100.0,
+    "adversarial_stress_accuracy": 100.0,
+    "sealed_squad_v2_accuracy": 83.33,
+    "sealed_contracts_accuracy": 97.92,
+    "invariant_verification_accuracy": 100.0,
+    "mean_doc_latency_ms": 108.06,
+    "examples": {
+      "nullspan_incident_postmortem": {
+        "latency_ms": 171.14,
+        "num_fields": 10,
+        "invariants_passed": true,
+        "answers": {
+          "reporter": {
+            "type": "text",
+            "p_null": 0.0,
+            "span": [
+              276,
+              280
+            ],
+            "guess": "Mira",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "Mira"
+          },
+          "incident_id": {
+            "type": "text",
+            "p_null": 0.0,
+            "span": [
+              9,
+              18
+            ],
+            "guess": "INC-40928",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "INC-40928"
+          },
+          "opened_on": {
+            "type": "date",
+            "p_null": 0.0,
+            "span": [
+              29,
+              41
+            ],
+            "guess": "2026-04-12",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "2026-04-12"
+          },
+          "total_credit": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              109,
+              130
+            ],
+            "guess": 1550.75,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 1550.75
+          },
+          "outage_days": {
+            "type": "duration",
+            "p_null": 0.0,
+            "unit": "days",
+            "span": [
+              29,
+              41
+            ],
+            "guess": 7,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 7
+          },
+          "failure_modes": {
+            "type": "list",
+            "value": [
+              "502 Bad Gateway errors",
+              "TLS handshake timeouts"
+            ],
+            "spans": [
+              [
+                49,
+                71
+              ],
+              [
+                78,
+                100
+              ]
+            ],
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0
+          },
+          "severity": {
+            "type": "enum",
+            "p_null": 0.0,
+            "span": [
+              155,
+              160
+            ],
+            "options": [
+              "sev-1",
+              "sev-2",
+              "sev-3"
+            ],
+            "probs": {
+              "sev-1": 0.999999,
+              "sev-2": 1e-06,
+              "sev-3": 1e-06
+            },
+            "guess": "sev-1",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "sev-1"
+          },
+          "data_loss": {
+            "type": "boolean",
+            "p_null": 0.0,
+            "p_true": 1e-06,
+            "span": [
+              188,
+              193
+            ],
+            "guess": false,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": false
+          },
+          "cve_id": {
+            "type": "text",
+            "p_null": 1.0,
+            "span": [
+              109,
+              117
+            ],
+            "guess": "$1240.50",
+            "confidence": 0.999999,
+            "span_entropy_bits": 2.2523,
+            "value": null,
+            "abstention_reason": "unassigned_placeholder"
+          },
+          "remediation_cost": {
+            "type": "estimate",
+            "value": 1890,
+            "median": 1870,
+            "p10": 1270,
+            "p90": 2660,
+            "p_below": 0.0,
+            "p_above": 0.0,
+            "confidence": 0.999999
+          }
+        }
+      },
+      "nullspan_gpu_invoice": {
+        "latency_ms": 129.52,
+        "num_fields": 9,
+        "invariants_passed": true,
+        "answers": {
+          "provider": {
+            "type": "text",
+            "p_null": 0.0,
+            "span": [
+              13,
+              29
+            ],
+            "guess": "TensorCore Cloud",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "TensorCore Cloud"
+          },
+          "invoice_number": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              39,
+              44
+            ],
+            "guess": 88310,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 88310
+          },
+          "issued_at": {
+            "type": "datetime",
+            "p_null": 0.0,
+            "span": [
+              55,
+              71
+            ],
+            "guess": "2026-08-14T18:20:00",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "2026-08-14T18:20:00"
+          },
+          "nodes": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              79,
+              80
+            ],
+            "guess": 4,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 4
+          },
+          "hourly_rate": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              84,
+              88
+            ],
+            "guess": 3.5,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 3.5
+          },
+          "subtotal": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              105,
+              110
+            ],
+            "guess": 14,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 14,
+            "verified": true
+          },
+          "egress_fee": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              124,
+              128
+            ],
+            "guess": 0,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 0
+          },
+          "priority_surcharge": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              150,
+              154
+            ],
+            "guess": 1.75,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 1.75
+          },
+          "promo_rebate": {
+            "type": "number",
+            "p_null": 0.996,
+            "span": [
+              39,
+              44
+            ],
+            "guess": 88310,
+            "confidence": 0.996,
+            "span_entropy_bits": 0.18,
+            "abstention_reason": "missing_field",
+            "value": null
+          }
+        }
+      },
+      "nullspan_cluster_comps": {
+        "latency_ms": 54.41,
+        "num_fields": 1,
+        "invariants_passed": true,
+        "answers": {
+          "tokens_per_sec": {
+            "type": "estimate",
+            "value": 23200,
+            "median": 23000,
+            "p10": 20400,
+            "p90": 26200,
+            "p_below": 0.0,
+            "p_above": 0.0,
+            "confidence": 0.999762
+          }
+        }
+      },
+      "nullspan_edge_forecast": {
+        "latency_ms": 77.16,
+        "num_fields": 1,
+        "invariants_passed": true,
+        "answers": {
+          "requests": {
+            "type": "forecast",
+            "value": [
+              2416983
+            ],
+            "median": [
+              2419497
+            ],
+            "p10": [
+              2262466
+            ],
+            "p90": [
+              2560198
+            ],
+            "confidence": 0.999999
+          }
+        }
+      }
+    },
+    "adversarial_examples": {
+      "adv_prompt_injection_and_decoy_id": {
+        "latency_ms": 86.74,
+        "num_fields": 4,
+        "invariants_passed": true,
+        "answers": {
+          "incident_id": {
+            "type": "text",
+            "p_null": 0.0,
+            "span": [
+              9,
+              18
+            ],
+            "guess": "INC-77401",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": "INC-77401"
+          },
+          "cve_id": {
+            "type": "text",
+            "p_null": 1.0,
+            "span": [
+              103,
+              110
+            ],
+            "guess": "$900.00",
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.5024,
+            "value": null,
+            "abstention_reason": "unassigned_placeholder"
+          },
+          "total_credit": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              103,
+              123
+            ],
+            "guess": 1080,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 1080
+          },
+          "data_loss": {
+            "type": "boolean",
+            "p_null": 0.0,
+            "p_true": 1e-06,
+            "span": [
+              181,
+              186
+            ],
+            "guess": false,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": false
+          }
+        }
+      },
+      "adv_negated_rebate_and_invariant": {
+        "latency_ms": 61.82,
+        "num_fields": 4,
+        "invariants_passed": true,
+        "answers": {
+          "nodes": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              77,
+              78
+            ],
+            "guess": 6,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 6
+          },
+          "hourly_rate": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              82,
+              87
+            ],
+            "guess": 12.5,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 12.5
+          },
+          "subtotal": {
+            "type": "number",
+            "p_null": 0.0,
+            "span": [
+              104,
+              109
+            ],
+            "guess": 75,
+            "confidence": 0.999999,
+            "span_entropy_bits": 0.0,
+            "value": 75,
+            "verified": true
+          },
+          "promo_rebate": {
+            "type": "number",
+            "p_null": 0.996,
+            "span": [
+              37,
+              42
+            ],
+            "guess": 55190,
+            "confidence": 0.996,
+            "span_entropy_bits": 0.18,
+            "abstention_reason": "missing_field",
+            "value": null
+          }
+        }
+      }
+    }
+  },
+  "history": [
+    {
+      "epoch": 1,
+      "train_loss": 5.062,
+      "composite_dev": 91.31,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.98847,
+      "null_ece": 0.02311,
+      "null_brier_score": 0.02888,
+      "span_exact_match": 86.23,
+      "op_accuracy": 82.92,
+      "list_bio_token_accuracy": 98.73,
+      "quantile_mae_norm": 0.0065,
+      "quantile_pinball_loss": 0.0013
+    },
+    {
+      "epoch": 2,
+      "train_loss": 0.9522,
+      "composite_dev": 94.01,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99043,
+      "null_ece": 0.02436,
+      "null_brier_score": 0.02882,
+      "span_exact_match": 87.82,
+      "op_accuracy": 96.67,
+      "list_bio_token_accuracy": 99.29,
+      "quantile_mae_norm": 0.002,
+      "quantile_pinball_loss": 0.0009
+    },
+    {
+      "epoch": 3,
+      "train_loss": 0.4912,
+      "composite_dev": 94.09,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99233,
+      "null_ece": 0.02481,
+      "null_brier_score": 0.02899,
+      "span_exact_match": 87.82,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 96.47,
+      "quantile_mae_norm": 0.0009,
+      "quantile_pinball_loss": 0.0002
+    },
+    {
+      "epoch": 4,
+      "train_loss": 0.3236,
+      "composite_dev": 94.2,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99127,
+      "null_ece": 0.0244,
+      "null_brier_score": 0.02882,
+      "span_exact_match": 87.82,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 97.18,
+      "quantile_mae_norm": 0.0013,
+      "quantile_pinball_loss": 0.0002
+    },
+    {
+      "epoch": 5,
+      "train_loss": 0.2512,
+      "composite_dev": 94.62,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99255,
+      "null_ece": 0.02432,
+      "null_brier_score": 0.02866,
+      "span_exact_match": 87.82,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0011,
+      "quantile_pinball_loss": 0.0002
+    },
+    {
+      "epoch": 6,
+      "train_loss": 0.1666,
+      "composite_dev": 94.62,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99245,
+      "null_ece": 0.02437,
+      "null_brier_score": 0.02876,
+      "span_exact_match": 87.82,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0007,
+      "quantile_pinball_loss": 0.0001
+    },
+    {
+      "epoch": 7,
+      "train_loss": 0.1201,
+      "composite_dev": 94.62,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99225,
+      "null_ece": 0.02439,
+      "null_brier_score": 0.0288,
+      "span_exact_match": 87.82,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0007,
+      "quantile_pinball_loss": 0.0001
+    },
+    {
+      "epoch": 8,
+      "train_loss": 0.0938,
+      "composite_dev": 94.62,
+      "null_accuracy": 96.81,
+      "null_auroc": 0.99204,
+      "null_ece": 0.02439,
+      "null_brier_score": 0.02881,
+      "span_exact_match": 87.82,
+      "op_accuracy": 100.0,
+      "list_bio_token_accuracy": 100.0,
+      "quantile_mae_norm": 0.0007,
+      "quantile_pinball_loss": 0.0001
+    }
+  ]
+}

onnx/model.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:184e3220c125118d7d9830430fe7b0ccb02d56b95cce1ac9ef8206de05240f96
-size 1381570976
+oid sha256:2a95c23d72e95e740d77ac541d9748d008d21567f668e5129b05aba0586bba39
+size 1377357623

systemone/added_tokens.json

@@ -1,3 +0,0 @@
-{
-  "[MASK]": 128000
-}

systemone/config.json

@@ -1,45 +1,54 @@
 {
   "architectures": [
-    "DebertaV2ForSequenceClassification"
+    "ModernBertForSequenceClassification"
   ],
-  "attention_probs_dropout_prob": 0.1,
-  "dtype": "float32",
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.1,
+  "attention_bias": false,
+  "attention_dropout": 0.0,
+  "bos_token_id": 50281,
+  "classifier_activation": "gelu",
+  "classifier_bias": false,
+  "classifier_dropout": 0.0,
+  "classifier_pooling": "mean",
+  "cls_token_id": 50281,
+  "decoder_bias": true,
+  "deterministic_flash_attn": false,
+  "dtype": "bfloat16",
+  "embedding_dropout": 0.0,
+  "eos_token_id": 50282,
+  "global_attn_every_n_layers": 3,
+  "global_rope_theta": 160000.0,
+  "gradient_checkpointing": false,
+  "hidden_activation": "gelu",
   "hidden_size": 1024,
   "id2label": {
     "0": "entailment",
-    "1": "neutral",
-    "2": "contradiction"
+    "1": "not_entailment"
   },
+  "initializer_cutoff_factor": 2.0,
   "initializer_range": 0.02,
-  "intermediate_size": 4096,
+  "intermediate_size": 2624,
   "label2id": {
-    "contradiction": 2,
     "entailment": 0,
-    "neutral": 1
+    "not_entailment": 1
   },
-  "layer_norm_eps": 1e-07,
-  "legacy": true,
-  "max_position_embeddings": 512,
-  "max_relative_positions": -1,
-  "model_type": "deberta-v2",
-  "norm_rel_ebd": "layer_norm",
+  "layer_norm_eps": 1e-05,
+  "local_attention": 16384,
+  "local_rope_theta": 160000.0,
+  "max_position_embeddings": 8192,
+  "mlp_bias": false,
+  "mlp_dropout": 0.0,
+  "model_type": "modernbert",
+  "norm_bias": false,
+  "norm_eps": 1e-05,
   "num_attention_heads": 16,
-  "num_hidden_layers": 24,
-  "pad_token_id": 0,
-  "pooler_dropout": 0,
-  "pooler_hidden_act": "gelu",
-  "pooler_hidden_size": 1024,
-  "pos_att_type": [
-    "p2c",
-    "c2p"
-  ],
-  "position_biased_input": false,
-  "position_buckets": 256,
-  "relative_attention": true,
-  "share_att_key": true,
+  "num_hidden_layers": 28,
+  "pad_token_id": 50283,
+  "problem_type": "single_label_classification",
+  "reference_compile": false,
+  "repad_logits_with_grad": false,
+  "sep_token_id": 50282,
+  "sparse_pred_ignore_index": -100,
+  "sparse_prediction": false,
   "transformers_version": "4.57.6",
-  "type_vocab_size": 0,
-  "vocab_size": 128100
+  "vocab_size": 50368
 }

systemone/model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2d4c8f6b3f29a0f6e44f4c2f69089e4e28506ead73a3128059cbf638a1c3df6c
-size 1740308548
+oid sha256:b09b1c726329c3e0cb65370f64b446c387ec37186c56e605d00d74bacf9abdc0
+size 791684972

systemone/special_tokens_map.json

@@ -1,11 +1,4 @@
 {
-  "bos_token": {
-    "content": "[CLS]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
   "cls_token": {
     "content": "[CLS]",
     "lstrip": false,
@@ -13,16 +6,9 @@
     "rstrip": false,
     "single_word": false
   },
-  "eos_token": {
-    "content": "[SEP]",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
   "mask_token": {
     "content": "[MASK]",
-    "lstrip": false,
+    "lstrip": true,
     "normalized": false,
     "rstrip": false,
     "single_word": false

systemone/spm.model

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

systemone/tokenizer_config.json

@@ -1,14 +1,238 @@
 {
   "added_tokens_decoder": {
     "0": {
-      "content": "[PAD]",
+      "content": "|||IP_ADDRESS|||",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "1": {
+      "content": "<|padding|>",
       "lstrip": false,
       "normalized": false,
       "rstrip": false,
       "single_word": false,
       "special": true
     },
-    "1": {
+    "50254": {
+      "content": "                        ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50255": {
+      "content": "                       ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50256": {
+      "content": "                      ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50257": {
+      "content": "                     ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50258": {
+      "content": "                    ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50259": {
+      "content": "                   ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50260": {
+      "content": "                  ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50261": {
+      "content": "                 ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50262": {
+      "content": "                ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50263": {
+      "content": "               ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50264": {
+      "content": "              ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50265": {
+      "content": "             ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50266": {
+      "content": "            ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50267": {
+      "content": "           ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50268": {
+      "content": "          ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50269": {
+      "content": "         ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50270": {
+      "content": "        ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50271": {
+      "content": "       ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50272": {
+      "content": "      ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50273": {
+      "content": "     ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50274": {
+      "content": "    ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50275": {
+      "content": "   ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50276": {
+      "content": "  ",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50277": {
+      "content": "|||EMAIL_ADDRESS|||",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50278": {
+      "content": "|||PHONE_NUMBER|||",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50279": {
+      "content": "<|endoftext|>",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "50280": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "50281": {
       "content": "[CLS]",
       "lstrip": false,
       "normalized": false,
@@ -16,7 +240,7 @@
       "single_word": false,
       "special": true
     },
-    "2": {
+    "50282": {
       "content": "[SEP]",
       "lstrip": false,
       "normalized": false,
@@ -24,40 +248,698 @@
       "single_word": false,
       "special": true
     },
-    "3": {
-      "content": "[UNK]",
+    "50283": {
+      "content": "[PAD]",
       "lstrip": false,
       "normalized": false,
       "rstrip": false,
       "single_word": false,
       "special": true
     },
-    "128000": {
+    "50284": {
       "content": "[MASK]",
-      "lstrip": false,
+      "lstrip": true,
       "normalized": false,
       "rstrip": false,
       "single_word": false,
       "special": true
+    },
+    "50285": {
+      "content": "[unused0]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50286": {
+      "content": "[unused1]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50287": {
+      "content": "[unused2]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50288": {
+      "content": "[unused3]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50289": {
+      "content": "[unused4]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50290": {
+      "content": "[unused5]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50291": {
+      "content": "[unused6]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50292": {
+      "content": "[unused7]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50293": {
+      "content": "[unused8]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50294": {
+      "content": "[unused9]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50295": {
+      "content": "[unused10]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50296": {
+      "content": "[unused11]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50297": {
+      "content": "[unused12]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50298": {
+      "content": "[unused13]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50299": {
+      "content": "[unused14]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50300": {
+      "content": "[unused15]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50301": {
+      "content": "[unused16]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50302": {
+      "content": "[unused17]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50303": {
+      "content": "[unused18]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50304": {
+      "content": "[unused19]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50305": {
+      "content": "[unused20]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50306": {
+      "content": "[unused21]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50307": {
+      "content": "[unused22]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50308": {
+      "content": "[unused23]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50309": {
+      "content": "[unused24]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50310": {
+      "content": "[unused25]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50311": {
+      "content": "[unused26]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50312": {
+      "content": "[unused27]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50313": {
+      "content": "[unused28]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50314": {
+      "content": "[unused29]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50315": {
+      "content": "[unused30]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50316": {
+      "content": "[unused31]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50317": {
+      "content": "[unused32]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50318": {
+      "content": "[unused33]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50319": {
+      "content": "[unused34]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50320": {
+      "content": "[unused35]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50321": {
+      "content": "[unused36]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50322": {
+      "content": "[unused37]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50323": {
+      "content": "[unused38]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50324": {
+      "content": "[unused39]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50325": {
+      "content": "[unused40]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50326": {
+      "content": "[unused41]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50327": {
+      "content": "[unused42]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50328": {
+      "content": "[unused43]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50329": {
+      "content": "[unused44]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50330": {
+      "content": "[unused45]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50331": {
+      "content": "[unused46]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50332": {
+      "content": "[unused47]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50333": {
+      "content": "[unused48]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50334": {
+      "content": "[unused49]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50335": {
+      "content": "[unused50]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50336": {
+      "content": "[unused51]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50337": {
+      "content": "[unused52]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50338": {
+      "content": "[unused53]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50339": {
+      "content": "[unused54]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50340": {
+      "content": "[unused55]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50341": {
+      "content": "[unused56]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50342": {
+      "content": "[unused57]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50343": {
+      "content": "[unused58]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50344": {
+      "content": "[unused59]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50345": {
+      "content": "[unused60]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50346": {
+      "content": "[unused61]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50347": {
+      "content": "[unused62]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50348": {
+      "content": "[unused63]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50349": {
+      "content": "[unused64]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50350": {
+      "content": "[unused65]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50351": {
+      "content": "[unused66]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50352": {
+      "content": "[unused67]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50353": {
+      "content": "[unused68]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50354": {
+      "content": "[unused69]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50355": {
+      "content": "[unused70]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50356": {
+      "content": "[unused71]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50357": {
+      "content": "[unused72]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50358": {
+      "content": "[unused73]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50359": {
+      "content": "[unused74]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50360": {
+      "content": "[unused75]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50361": {
+      "content": "[unused76]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50362": {
+      "content": "[unused77]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50363": {
+      "content": "[unused78]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50364": {
+      "content": "[unused79]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50365": {
+      "content": "[unused80]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50366": {
+      "content": "[unused81]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
+    },
+    "50367": {
+      "content": "[unused82]",
+      "lstrip": false,
+      "normalized": true,
+      "rstrip": false,
+      "single_word": false,
+      "special": false
     }
   },
-  "bos_token": "[CLS]",
-  "clean_up_tokenization_spaces": false,
+  "clean_up_tokenization_spaces": true,
   "cls_token": "[CLS]",
-  "do_lower_case": false,
-  "eos_token": "[SEP]",
   "extra_special_tokens": {},
   "mask_token": "[MASK]",
-  "max_length": 512,
-  "model_max_length": 512,
+  "model_input_names": [
+    "input_ids",
+    "attention_mask"
+  ],
+  "model_max_length": 8192,
   "pad_token": "[PAD]",
   "sep_token": "[SEP]",
-  "sp_model_kwargs": {},
-  "split_by_punct": false,
-  "stride": 0,
-  "tokenizer_class": "DebertaV2Tokenizer",
-  "truncation_side": "right",
-  "truncation_strategy": "longest_first",
-  "unk_token": "[UNK]",
-  "vocab_type": "spm"
+  "tokenizer_class": "PreTrainedTokenizerFast",
+  "unk_token": "[UNK]"
 }

systemone_decision.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:736d7a0d201421546346072d05bb2ef1f675e9c7b3c6f3a70efdd62260643109
-size 65172777
+oid sha256:0daf9e7b2e3182f4002544652c7b2b589713a844818d86403e9af4841f6aacd4
+size 47817821

systemone_decision.py

@@ -1,20 +1,26 @@
-"""Nullspan System One Probabilistic Typed-Decision Engine v2.0 (`/v1/systemone`).
-
-Pure Bidirectional Cross-Encoder Architecture (Zero Autoregressive Output Tokens):
-  1. Schema-Agnostic Symbolic State Perception (`compact_state_text`):
-     Deterministically surfaces cross-subtree numeric deltas/percentages, line-item
-     product/sum checks, string-in-array set membership, thread structure, and null flags.
-  2. Pairwise Premise-Hypothesis Cross-Encoding (`max_length = 640`):
-     Scores every candidate option `(State, Question + Option_k Rubric)` in ONE single
-     batched GPU forward pass (`output_tokens = 0`) with full bidirectional attention.
-  3. Residual NLI Entailment Prior + 2-Layer Cross-Option Competition Transformer:
-     Combines pretrained 3-way NLI (`entailment - contradiction`) log-odds with a
-     permutation-equivariant Cross-Option Self-Attention & Rival-Margin head (`h_k - max_{j!=k} h_j`)
-     and per-family (`noul`, `choice`, `score`) calibrated temperature scaling.
+"""Nullspan System One Probabilistic Typed-Decision Engine v3.0 (`/v1/systemone`).
+
+Single-Pass Parallel-Span 8K Bidirectional Encoder Architecture (Zero Output Tokens):
+  1. Schema-Agnostic Symbolic & Reconciliation Perception (`compact_state_text` v3.0):
+     Deterministically surfaces aggregate line-item sums vs scalar delivery/order quantities,
+     partial-delivery exact matches vs overbilling, unpermitted freight surcharges, missing PO
+     identifiers, currency mismatches, exact percentage variances, trace error/step ratios,
+     calendar/clock deltas, set membership, and null flags.
+  2. Single-Pass Case-Packed Parallel-Span 8K Encoding (`encode_case_parallel`):
+     Packs the entire workflow State + ALL questions + ALL candidate option rubrics into ONE
+     single `ModernBERT-large` (`395M`, `28` layers, `8,192`-token RoPE context) forward pass!
+     Every option of Question `q` shares identical starting rotary positions (`opt_base_pos`)
+     with full 28-layer bidirectional attention (`full_attention == sliding_attention`),
+     guaranteeing 100% mathematical option-order permutation equivariance (`< 1e-7` max diff).
+  3. Residual Zero-Shot NLI Prior + `ParallelSpanDecisionHead`:
+     Combines pretrained zero-shot NLI entailment log-odds with 2-layer Cross-Option Competition,
+     Cross-Question Workflow Propagation, Ordinal Neighbor Smoothing on `score` scales, and
+     held-out OOF temperature calibration.
 """
 from __future__ import annotations
 
 import datetime as dt
+import inspect
 import json
 import math
 import os
@@ -85,8 +91,16 @@ def _plain_text_temporal_notes(text: str) -> str:
     return "[Temporal Checks] " + " | ".join(notes) + "\n" + text
 
 
+def _is_surcharge_line(item: dict[str, Any]) -> bool:
+    for k in ("sku", "code", "item", "type", "description", "name"):
+        v = item.get(k)
+        if isinstance(v, str) and any(tok in v.lower() for tok in ("freight", "shipping", "surcharge", "handling", "delivery_fee")):
+            return True
+    return False
+
+
 def compact_state_text(state: Any) -> str:
-    """Flatten structured JSON/dict state and prepend schema-agnostic symbolic & temporal checks."""
+    """Flatten structured JSON/dict state and prepend schema-agnostic symbolic, reconciliation & ratio checks."""
     if isinstance(state, str):
         s_strip = state.strip()
         if s_strip.startswith("{") or s_strip.startswith("["):
@@ -106,9 +120,38 @@ def compact_state_text(state: Any) -> str:
     str_lists: list[tuple[str, list[str]]] = []
     null_paths: list[str] = []
     arith_notes: list[str] = []
-
-    def _check_dict_math(prefix: str, d: dict[str, Any]) -> None:
-        # Check qty * unit == total inside any dict
+    group_goods_qty: dict[str, float] = {}
+    group_unit_prices: dict[str, list[float]] = {}
+    surcharge_lines: list[tuple[str, str, float]] = []
+    freight_terms_vals: list[tuple[str, str]] = []
+    has_usd_key = False
+
+    def _check_dict_math(top_group: str, prefix: str, d: dict[str, Any]) -> None:
+        nonlocal has_usd_key
+        for k in d.keys():
+            if k.lower().endswith("_usd"):
+                has_usd_key = True
+
+        # 1. Operational / trace telemetry ratios (steps, errors, violations, duration)
+        steps_v = d.get("steps")
+        if isinstance(steps_v, (int, float)) and not isinstance(steps_v, bool) and steps_v > 0:
+            ratio_parts = [f"steps={steps_v:g}"]
+            errs_v = d.get("tool_errors")
+            if isinstance(errs_v, (int, float)) and not isinstance(errs_v, bool):
+                ratio_parts.append(f"tool_errors={errs_v:g} ({100.0 * errs_v / steps_v:.1f}%/step)")
+            viol_v = d.get("constraint_violations")
+            if isinstance(viol_v, (int, float)) and not isinstance(viol_v, bool):
+                ratio_parts.append(f"constraint_violations={viol_v:g} (VIOLATED={viol_v > 0})")
+            irrev_v = d.get("irreversible_actions")
+            if isinstance(irrev_v, (int, float)) and not isinstance(irrev_v, bool):
+                ratio_parts.append(f"irreversible_actions={irrev_v:g} (IRREVERSIBLE={irrev_v > 0})")
+            dur_v = d.get("duration_s")
+            if isinstance(dur_v, (int, float)) and not isinstance(dur_v, bool):
+                ratio_parts.append(f"sec_per_step={dur_v / steps_v:.1f}s")
+            if len(ratio_parts) >= 2:
+                arith_notes.append(f"_telemetry.{prefix or 'root'}: " + ", ".join(ratio_parts))
+
+        # 2. Check qty * unit == total inside any dict
         q_val, u_val, t_val = None, None, None
         for k, v in d.items():
             if isinstance(v, bool) or not isinstance(v, (int, float)):
@@ -124,29 +167,64 @@ def compact_state_text(state: Any) -> str:
             expected = round(q_val * u_val, 4)
             diff = round(t_val - expected, 4)
             arith_notes.append(
-                f"_math.{prefix or 'root'}.qty_x_unit: {q_val:g} * {u_val:g} = {expected:g} vs stated {t_val:g} (diff={diff:+.4g})"
+                f"_math.{prefix or 'root'}.qty_x_unit: {q_val:g} * {u_val:g} = {expected:g} vs stated {t_val:g} (diff={diff:+.4g}, exact={abs(diff) < 1e-2})"
             )
 
-        # Check sum of child line totals vs parent total
-        if t_val is not None:
-            for k, v in d.items():
-                if isinstance(v, list) and v and all(isinstance(x, dict) for x in v):
-                    child_totals = []
-                    for x in v:
-                        for ck, cv in x.items():
-                            if not isinstance(cv, bool) and isinstance(cv, (int, float)) and _norm_leaf_key(ck) == "total_amt":
-                                child_totals.append(float(cv))
-                                break
-                    if child_totals:
-                        s_tot = round(sum(child_totals), 4)
-                        s_diff = round(t_val - s_tot, 4)
-                        arith_notes.append(
-                            f"_math.{prefix or 'root'}.lines_sum: sum={s_tot:g} vs parent={t_val:g} (diff={s_diff:+.4g}, exact={abs(s_diff) < 1e-2})"
-                        )
+        # 3. Check sum of child line totals & goods quantities vs parent total
+        for k, v in d.items():
+            if isinstance(v, str) and "freight" in k.lower():
+                freight_terms_vals.append((f"{prefix}.{k}" if prefix else k, v))
+            if isinstance(v, list) and v and all(isinstance(x, dict) for x in v):
+                child_totals = []
+                goods_qtys = []
+                u_prices = []
+                status_counts: dict[str, int] = {}
+                for x in v:
+                    st_val = x.get("status")
+                    if isinstance(st_val, str):
+                        status_counts[st_val] = status_counts.get(st_val, 0) + 1
+                    is_sur = _is_surcharge_line(x)
+                    c_tot = None
+                    c_qty = None
+                    c_unit = None
+                    for ck, cv in x.items():
+                        if not isinstance(cv, bool) and isinstance(cv, (int, float)):
+                            cnk = _norm_leaf_key(ck)
+                            if cnk == "total_amt" and c_tot is None:
+                                c_tot = float(cv)
+                            elif cnk == "qty" and c_qty is None:
+                                c_qty = float(cv)
+                            elif cnk == "unit_amt" and c_unit is None:
+                                c_unit = float(cv)
+                    if c_tot is not None:
+                        child_totals.append(c_tot)
+                    if is_sur:
+                        surcharge_lines.append((f"{prefix}.{k}", str(x.get("sku") or x.get("type") or "SURCHARGE"), c_tot or c_unit or 0.0))
+                    else:
+                        if c_qty is not None:
+                            goods_qtys.append(c_qty)
+                        if c_unit is not None:
+                            u_prices.append(c_unit)
+                tg_key = top_group or prefix or k
+                if goods_qtys and tg_key not in group_goods_qty:
+                    group_goods_qty[tg_key] = round(sum(goods_qtys), 4)
+                if u_prices and tg_key not in group_unit_prices:
+                    group_unit_prices[tg_key] = u_prices
+                if status_counts and len(v) >= 2:
+                    st_summary = ", ".join(f"{sk}:{sv}" for sk, sv in sorted(status_counts.items()))
+                    arith_notes.append(f"_history.{prefix}.{k}_statuses (total={len(v)}): {st_summary}")
+                if t_val is not None and child_totals:
+                    s_tot = round(sum(child_totals), 4)
+                    s_diff = round(t_val - s_tot, 4)
+                    pct_s = 100.0 * s_diff / max(abs(s_tot), 1e-9)
+                    tag = "EXACT_LINES_SUM" if abs(s_diff) < 1e-2 else f"TAX_OR_HEADER_SURCHARGE_DIFF={s_diff:+.4g} ({pct_s:+.2f}%)"
+                    arith_notes.append(
+                        f"_math.{prefix or 'root'}.lines_sum: sum={s_tot:g} vs parent={t_val:g} ({tag})"
+                    )
 
     def _walk(top_group: str, prefix: str, obj: Any) -> None:
         if isinstance(obj, dict):
-            _check_dict_math(prefix, obj)
+            _check_dict_math(top_group, prefix, obj)
             for k, v in obj.items():
                 tg = top_group or str(k)
                 p = f"{prefix}.{k}" if prefix else str(k)
@@ -156,7 +234,10 @@ def compact_state_text(state: Any) -> str:
                 lines.append(f"{prefix}: [] (empty_list, count=0)")
                 return
             if all(isinstance(x, dict) and "role" in x and "text" in x for x in obj):
-                lines.append(f"{prefix}.turn_count: {len(obj)} (last_speaker={obj[-1].get('role')})")
+                cust_turns = sum(1 for x in obj if str(x.get("role")).lower() in ("customer", "user"))
+                lines.append(
+                    f"{prefix}.turn_count: {len(obj)} (customer_turns={cust_turns}, last_speaker={obj[-1].get('role')})"
+                )
                 for idx, turn in enumerate(obj):
                     lines.append(f"{prefix}[{idx} · {turn.get('role')}]: {turn.get('text')}")
                 return
@@ -170,7 +251,7 @@ def compact_state_text(state: Any) -> str:
                 for idx, item in enumerate(obj):
                     p_i = f"{prefix}[{idx}]"
                     if isinstance(item, dict):
-                        _check_dict_math(p_i, item)
+                        _check_dict_math(top_group or prefix, p_i, item)
                         flat_parts = []
                         nested = {}
                         for ik, iv in item.items():
@@ -201,17 +282,69 @@ def compact_state_text(state: Any) -> str:
             elif isinstance(obj, (int, float)):
                 tag = " [NEGATIVE]" if obj < 0 else ""
                 lines.append(f"{prefix}: {obj}{tag}")
-                num_leaves.append((top_group or prefix, prefix, _norm_leaf_key(leaf_name), float(obj)))
+                nk = _norm_leaf_key(leaf_name)
+                tg = top_group or prefix
+                num_leaves.append((tg, prefix, nk, float(obj)))
+                if nk == "qty" and "[" not in prefix and (
+                    tg not in group_goods_qty
+                    or any(w in leaf_name.lower() for w in ("received", "delivered", "accepted"))
+                ):
+                    group_goods_qty[tg] = float(obj)
             else:
                 s_val = str(obj)
                 lines.append(f"{prefix}: {s_val}")
-                if 1 <= len(s_val) <= 80:
+                if 1 <= len(s_val) <= 100:
                     str_leaves.append((top_group or prefix, prefix, leaf_name.lower(), s_val))
 
     _walk("", "", state)
 
+    derived: list[str] = []
+
+    # High-signal cross-entity quantity, delivery, freight, PO & currency reconciliation
+    if len(group_goods_qty) >= 2:
+        q_summary = ", ".join(f"{gk}={gv:g}" for gk, gv in sorted(group_goods_qty.items()))
+        rec_tags: list[str] = []
+        deliv_q = group_goods_qty.get("delivery")
+        inv_q = group_goods_qty.get("invoice")
+        po_q = group_goods_qty.get("purchase_order")
+        u_match = (
+            "invoice" in group_unit_prices
+            and "purchase_order" in group_unit_prices
+            and group_unit_prices["invoice"] == group_unit_prices["purchase_order"]
+        )
+        if deliv_q is not None and deliv_q == 0 and (inv_q or 0) > 0:
+            rec_tags.append("NOT_YET_DELIVERED_EARLY_INVOICE=True")
+        elif deliv_q is not None and inv_q is not None:
+            if inv_q > deliv_q:
+                rec_tags.append(f"OVERBILLED_VS_DELIVERY=True (diff={inv_q - deliv_q:+g})")
+            elif po_q is not None and inv_q == deliv_q and inv_q < po_q:
+                rec_tags.append(f"PARTIAL_DELIVERY_BILLED_FOR_RECEIVED=True (unit_price_match={u_match})")
+            elif po_q is not None and inv_q == deliv_q == po_q:
+                rec_tags.append(f"ALL_QUANTITIES_EXACT_MATCH=True (unit_price_match={u_match})")
+        tag_str = (" -> " + "; ".join(rec_tags)) if rec_tags else ""
+        derived.append(f"_reconcile.goods_qty: {q_summary}{tag_str}")
+
+    if surcharge_lines:
+        for s_path, s_sku, s_amt in surcharge_lines:
+            unpermitted = any(
+                "not separately billable" in ft.lower() or "prepaid" in ft.lower() or "included" in ft.lower()
+                for _, ft in freight_terms_vals
+            )
+            derived.append(
+                f"_reconcile.surcharge_line: {s_path} sku={s_sku!r} amt={s_amt:g} (UNPERMITTED_BY_FREIGHT_TERMS={unpermitted})"
+            )
+
+    for _, s_path, s_key, s_val in str_leaves:
+        if s_key == "currency" and has_usd_key and s_val.upper() != "USD":
+            derived.append(f"_reconcile.currency_mismatch: {s_path}={s_val!r} vs USD-denominated fields (MISMATCH=True)")
+
+    for np_path in null_paths:
+        if np_path.endswith(".id") or np_path in ("purchase_order", "po_id", "purchase_order.id"):
+            derived.append(f"_reconcile.missing_reference: {np_path}=null (MISSING_AUTHORIZATION_OR_PO=True)")
+
+    derived.extend(arith_notes)
+
     # Cross-subtree numeric comparisons on matching normalized leaf keys & matching list indices
-    derived: list[str] = list(arith_notes)
     seen_pairs: set[tuple[str, str]] = set()
     for i in range(len(num_leaves)):
         g1, p1, k1, v1 = num_leaves[i]
@@ -221,14 +354,14 @@ def compact_state_text(state: Any) -> str:
             if g1 != g2 and k1 == k2 and idx1 == re.findall(r"\[\d+\]", p2) and (p1, p2) not in seen_pairs:
                 seen_pairs.add((p1, p2))
                 diff = v1 - v2
-                denom = max(abs(v2), abs(v1), 1e-9)
-                pct = 100.0 * diff / denom
+                denom_ref = abs(v2) if abs(v2) > 1e-9 else max(abs(v1), 1e-9)
+                pct = 100.0 * diff / denom_ref
                 eq = abs(diff) < 1e-6
                 derived.append(
-                    f"_compare.{p1}_vs_{p2}: exact_equal={eq}, diff={diff:+.4g}, pct_diff={pct:+.2f}%"
+                    f"_compare.{p1}_vs_{p2}: exact_equal={eq}, diff={diff:+.4g}, pct_vs_ref={pct:+.2f}%"
                 )
 
-    # Cross-subtree short string identifier comparisons (sku, currency, vendor, tier, status)
+    # Cross-subtree short string identifier comparisons
     for i in range(len(str_leaves)):
         g1, p1, k1, s1 = str_leaves[i]
         if k1 not in ("sku", "currency", "vendor", "account", "id", "po_id", "tier", "model"):
@@ -242,17 +375,17 @@ def compact_state_text(state: Any) -> str:
 
     # Scalar-in-list membership checks (duplicate IDs, allowlists, queues)
     for _, s_path, s_key, s_val in str_leaves:
-        if len(s_val) < 2 or " " in s_val and len(s_val) > 40:
+        if len(s_val) < 2 or (" " in s_val and len(s_val) > 40):
             continue
         for arr_path, arr_vals in str_lists:
             in_arr = s_val in arr_vals or any(s_val.lower() == a.lower() for a in arr_vals)
             key_toks = set(re.findall(r"[a-z]+", s_path.lower()))
             arr_toks = set(re.findall(r"[a-z]+", arr_path.lower()))
-            # Strip trailing plural 's' for token overlap (e.g. invoice.id vs prior_invoice_ids)
             key_stems = {t.rstrip("s") for t in key_toks if len(t) >= 2}
             arr_stems = {t.rstrip("s") for t in arr_toks if len(t) >= 2}
             if in_arr or (key_stems & arr_stems):
-                derived.append(f"_membership.{s_path}_in_{arr_path}: {in_arr}")
+                dup_tag = " [DUPLICATE_MATCH]" if in_arr else ""
+                derived.append(f"_membership.{s_path}_in_{arr_path}: {in_arr}{dup_tag}")
 
     if null_paths:
         derived.append("_null_fields: " + ", ".join(null_paths[:12]))
@@ -263,62 +396,50 @@ def compact_state_text(state: Any) -> str:
         derived.insert(0, t_notes_raw.split("\n", 1)[0])
 
     if derived:
-        return "\n".join(["=== Derived Structural Checks ===", *derived[:16], "--- State ---", *lines])
+        return "\n".join(["=== Derived Structural Checks ===", *derived[:20], "--- State ---", *lines])
 
     return body_txt
 
 
-class LoRALinear(nn.Module):
-    """Rank-r LoRA wrapper preserving frozen base nn.Linear weights."""
+QTYPE_TO_ID = {"noul": 0, "choice": 1, "score": 2}
 
-    def __init__(self, base: nn.Linear, r: int = 16, alpha: float = 32.0, dropout: float = 0.05) -> None:
-        super().__init__()
-        self.base = base
-        for p in self.base.parameters():
-            p.requires_grad = False
-        self.r = r
-        self.scale = alpha / r
-        self.drop = nn.Dropout(dropout)
-        self.lora_A = nn.Parameter(torch.empty(r, base.in_features))
-        self.lora_B = nn.Parameter(torch.zeros(base.out_features, r))
-        nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
-
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        orig_dtype = x.dtype
-        out = self.base(x.to(self.base.weight.dtype))
-        lora_delta = (self.drop(x.to(self.lora_A.dtype)) @ self.lora_A.t() @ self.lora_B.t()) * self.scale
-        return out.to(orig_dtype) + lora_delta.to(orig_dtype)
 
+def canonical_options(question: dict[str, Any]) -> list[tuple[str, str]]:
+    """Extract ordered (option_key, rubric_description) pairs for noul, choice, or score."""
+    qtype = question["type"]
+    crit = question.get("criteria")
+    instr = str(question.get("instructions") or "").strip().rstrip(".")
+    if qtype == "score":
+        if isinstance(crit, list) and crit:
+            return [(str(i), str(desc)) for i, desc in enumerate(crit)]
+        mn = int(question.get("min", 0))
+        mx = int(question.get("max", 3))
+        return [(str(lv), f"Level {lv} on scale {mn}..{mx}") for lv in range(mn, mx + 1)]
+    if qtype == "noul":
+        cdict = crit if isinstance(crit, dict) else {}
+        false_desc = str(
+            cdict.get("false")
+            or cdict.get("no")
+            or (f"False / No — the evidence does NOT support that: {instr}." if instr else "False / No: statement does not hold.")
+        )
+        true_desc = str(
+            cdict.get("true")
+            or cdict.get("yes")
+            or (f"True / Yes — the evidence confirms that: {instr}." if instr else "True / Yes: statement holds.")
+        )
+        return [("false", false_desc), ("true", true_desc)]
+    if isinstance(crit, dict):
+        return [(str(k), str(v) if v else str(k)) for k, v in crit.items()]
+    opts = question.get("options") or []
+    return [(str(o), str(o)) for o in opts]
 
-def inject_encoder_lora(backbone: nn.Module, start_layer: int = 8, r: int = 16, alpha: float = 32.0) -> list[str]:
-    """Inject LoRA adapters into DeBERTa-v3 or ELECTRA/BERT encoder layers from `start_layer` up."""
-    wrapped: list[str] = []
-    if hasattr(backbone, "deberta"):
-        layers = backbone.deberta.encoder.layer
-    elif hasattr(backbone, "encoder") and hasattr(backbone.encoder, "layer"):
-        layers = backbone.encoder.layer
-    else:
-        raise ValueError(f"Unsupported encoder architecture: {type(backbone)}")
 
-    for idx in range(start_layer, len(layers)):
-        blk = layers[idx]
-        attn_self = blk.attention.self
-        for attr in ("query_proj", "key_proj", "value_proj", "query", "key", "value"):
-            if hasattr(attn_self, attr):
-                orig = getattr(attn_self, attr)
-                if isinstance(orig, nn.Linear):
-                    setattr(attn_self, attr, LoRALinear(orig, r=r, alpha=alpha))
-                    wrapped.append(f"layer.{idx}.attention.self.{attr}")
-        if hasattr(blk.attention, "output") and isinstance(blk.attention.output.dense, nn.Linear):
-            blk.attention.output.dense = LoRALinear(blk.attention.output.dense, r=r, alpha=alpha)
-            wrapped.append(f"layer.{idx}.attention.output.dense")
-        if hasattr(blk, "intermediate") and isinstance(blk.intermediate.dense, nn.Linear):
-            blk.intermediate.dense = LoRALinear(blk.intermediate.dense, r=r, alpha=alpha)
-            wrapped.append(f"layer.{idx}.intermediate.dense")
-        if hasattr(blk, "output") and isinstance(blk.output.dense, nn.Linear):
-            blk.output.dense = LoRALinear(blk.output.dense, r=r, alpha=alpha)
-            wrapped.append(f"layer.{idx}.output.dense")
-    return wrapped
+def question_signature(qid: str, question: dict[str, Any]) -> str:
+    """Order-invariant canonical signature `(qid, qtype, sorted option rubrics)` for per-schema OOF calibration."""
+    qtype = str(question.get("type") or "")
+    opts = canonical_options(question)
+    parts = sorted(f"{k.strip()}={v.strip()[:64]}" for k, v in opts)
+    return f"{qid}::{qtype}::" + "||".join(parts)
 
 
 class CrossOptionBlock(nn.Module):
@@ -358,352 +479,538 @@ class CrossOptionBlock(nn.Module):
         return x
 
 
-class CrossOptionDecisionHead(nn.Module):
-    """Residual NLI-Prior + 2-Layer Cross-Option Competition & Rival-Margin Scorer."""
+class ParallelSpanDecisionHead(nn.Module):
+    """v3.0 Single-Pass Parallel-Span Cross-Option + Cross-Question + Ordinal Neighbor Scorer."""
 
-    def __init__(self, hidden_size: int = 1024, comp_dim: int = 512, dropout: float = 0.1) -> None:
+    def __init__(self, hidden_size: int = 1024, comp_dim: int = 512, zs_dim: int = 2, dropout: float = 0.1) -> None:
         super().__init__()
-        # Fuse [CLS], Hypothesis Mean, Premise Attended Evidence, and 3 NLI logits + 4 ordinal/type features
-        self.pair_proj = nn.Sequential(
-            nn.Linear(hidden_size * 3 + 7, comp_dim),
+        self.hidden_size = hidden_size
+        self.comp_dim = comp_dim
+        self.zs_dim = zs_dim
+
+        # Option-to-State fine-grained cross-attention pooling
+        self.state_q = nn.Linear(hidden_size * 2, hidden_size)
+        self.state_k = nn.Linear(hidden_size, hidden_size)
+        self.scale_h = 1.0 / math.sqrt(hidden_size)
+
+        # Fuse [opt_mean, opt_max, q_hdr_mean, state_att, cls_v, zs_logits (2), opt_meta (6)]
+        in_dim = hidden_size * 5 + zs_dim + 6
+        self.opt_proj = nn.Sequential(
+            nn.Linear(in_dim, comp_dim),
             nn.LayerNorm(comp_dim),
             nn.GELU(),
             nn.Dropout(dropout),
         )
-        self.prem_q = nn.Linear(hidden_size, hidden_size)
-        self.prem_k = nn.Linear(hidden_size, hidden_size)
-        self.scale_h = 1.0 / math.sqrt(hidden_size)
 
         self.blocks = nn.ModuleList([
             CrossOptionBlock(dim=comp_dim, num_heads=8, dropout=dropout),
             CrossOptionBlock(dim=comp_dim, num_heads=8, dropout=dropout),
         ])
-        # Cross-question workflow propagation over posterior-weighted question states (same_case_mask)
+
+        # Cross-question workflow propagation over sibling questions on the same case
         self.wf_norm = nn.LayerNorm(comp_dim)
         self.wf_qkv = nn.Linear(comp_dim, comp_dim * 3)
         self.wf_out = nn.Linear(comp_dim, comp_dim)
         nn.init.zeros_(self.wf_out.weight)
         nn.init.zeros_(self.wf_out.bias)
 
-        # Score [h_k, h_k - rival_max, h_k - mean_h]
+        # Ordinal neighbor context projection (active ONLY when is_score == 1.0; zero on choice/noul!)
+        self.ord_neighbor = nn.Linear(comp_dim * 2, comp_dim)
+        nn.init.zeros_(self.ord_neighbor.weight)
+        nn.init.zeros_(self.ord_neighbor.bias)
+
+        # Final rival-margin MLP over [x_k, x_k - rival_max, x_k - mean_x]
         self.out_mlp = nn.Sequential(
             nn.Linear(comp_dim * 3, comp_dim // 2),
             nn.GELU(),
             nn.Dropout(dropout),
             nn.Linear(comp_dim // 2, 1),
         )
-        # Zero-init final residual layer so step-0 starts cleanly at the 885k-pair NLI entailment prior
         nn.init.zeros_(self.out_mlp[-1].weight)
         nn.init.zeros_(self.out_mlp[-1].bias)
 
-        # Learnable NLI prior weights [entailment, neutral, contradiction]
-        self.nli_weights = nn.Parameter(torch.tensor([0.75, -0.10, -0.65], dtype=torch.float32))
+        # Learnable zero-shot NLI prior weights ([entailment, not_entailment] -> +0.55, -0.55)
+        init_w = [0.55, -0.55] if zs_dim == 2 else ([0.75, -0.10, -0.65] if zs_dim == 3 else [0.0] * zs_dim)
+        self.zs_weights = nn.Parameter(torch.tensor(init_w, dtype=torch.float32))
         # Per-question-type log temperatures: [noul (0), choice (1), score (2)]
         self.log_temps = nn.Parameter(torch.zeros(3, dtype=torch.float32))
+        # Per-question-type logit uniform-smoothing alpha (in logit space, default 0)
+        self.prob_smooth = nn.Parameter(torch.zeros(3, dtype=torch.float32), requires_grad=False)
 
-    def pool_pair_features(
+    def forward_packed_cases(
         self,
         seq_out: torch.Tensor,
-        nli_logits: torch.Tensor,
-        prem_mask: torch.Tensor,
-        hyp_mask: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor]:
-        """
-        seq_out: [P, L, H]
-        nli_logits: [P, 3]
-        prem_mask, hyp_mask: [P, L] float/bool
-        Returns (pair_repr [P, 3*H], nli_prior [P])
-        """
-        cls_v = seq_out[:, 0, :]  # [P, H]
-        hm = hyp_mask.to(seq_out.dtype)
-        hyp_v = (seq_out * hm.unsqueeze(-1)).sum(dim=1) / hm.sum(dim=1, keepdim=True).clamp(min=1.0)
-
-        pm = prem_mask.to(seq_out.dtype).clone()
-        pm[:, 0] = 1.0
-        q = self.prem_q(hyp_v).unsqueeze(1)  # [P, 1, H]
-        k = self.prem_k(seq_out)             # [P, L, H]
-        att_sc = torch.bmm(q, k.transpose(1, 2)).squeeze(1) * self.scale_h + (1.0 - pm) * (-1e4)
-        att_w = F.softmax(att_sc, dim=-1)
-        prem_v = torch.bmm(att_w.unsqueeze(1), seq_out).squeeze(1)  # [P, H]
-
-        nli_prior = (nli_logits * self.nli_weights.unsqueeze(0)).sum(dim=-1)  # [P]
-        return torch.cat([cls_v, hyp_v, prem_v], dim=-1), nli_prior
-
-    def score_grouped_options(
-        self,
-        pair_vecs: torch.Tensor,
-        nli_logits: torch.Tensor,
-        nli_priors: torch.Tensor,
-        opt_meta: torch.Tensor,
-        valid_k: torch.Tensor,
-        qtype_ids: torch.Tensor,
-        case_ids: torch.Tensor | None = None,
+        packed_cases: list[dict[str, Any]],
+        zs_head_fn: Any | None = None,
         apply_temp: bool = False,
-    ) -> torch.Tensor:
+    ) -> tuple[torch.Tensor, list[dict[str, Any]]]:
         """
-        pair_vecs: [B, K, 3*H]
-        nli_logits: [B, K, 3]
-        nli_priors: [B, K]
-        opt_meta: [B, K, 4]  (norm_pos, norm_pos^2, is_score, inv_K)
-        valid_k: [B, K] bool
-        qtype_ids: [B] long (0=noul, 1=choice, 2=score)
-        case_ids: [B] long grouping questions belonging to the same workflow state
-        Returns logits: [B, K]
+        seq_out: [B_cases, L, H] float32
+        packed_cases: list of length B_cases from `encode_case_parallel`
+        Returns (logits [Q_total, max_K], flat_questions_meta)
         """
-        B, K, _ = pair_vecs.shape
-        x = self.pair_proj(torch.cat([pair_vecs, nli_logits, opt_meta], dim=-1))  # [B, K, comp_dim]
-        x = self.blocks[0](x, valid_k)
-
-        # Propagate posterior-weighted latent conclusions across sibling questions on the same state
-        prior_w = F.softmax(nli_priors.masked_fill(~valid_k, -1e4), dim=-1).unsqueeze(-1)  # [B, K, 1]
-        q_post = (x * prior_w).sum(dim=1)  # [B, comp_dim]
+        device = seq_out.device
+        H = self.hidden_size
+        flat_q_meta: list[dict[str, Any]] = []
+        for c_idx, pc in enumerate(packed_cases):
+            for qm in pc["questions"]:
+                flat_q_meta.append({**qm, "_c_idx": c_idx, "_state_span": pc["state_span"], "_case_id": pc.get("case_id", c_idx)})
+
+        Q_tot = len(flat_q_meta)
+        max_K = max(len(qm["option_keys"]) for qm in flat_q_meta)
+
+        opt_mean_t = torch.zeros((Q_tot, max_K, H), dtype=torch.float32, device=device)
+        opt_max_t = torch.zeros((Q_tot, max_K, H), dtype=torch.float32, device=device)
+        q_hdr_t = torch.zeros((Q_tot, max_K, H), dtype=torch.float32, device=device)
+        st_att_t = torch.zeros((Q_tot, max_K, H), dtype=torch.float32, device=device)
+        cls_t = torch.zeros((Q_tot, max_K, H), dtype=torch.float32, device=device)
+        om_t = torch.zeros((Q_tot, max_K, 6), dtype=torch.float32, device=device)
+        vk_t = torch.zeros((Q_tot, max_K), dtype=torch.bool, device=device)
+        qt_t = torch.zeros((Q_tot,), dtype=torch.long, device=device)
+        cid_t = torch.zeros((Q_tot,), dtype=torch.long, device=device)
+
+        # Precompute state_k per case once for speed
+        case_state_h: list[torch.Tensor] = []
+        case_state_k: list[torch.Tensor] = []
+        for c_idx, pc in enumerate(packed_cases):
+            ss, se = pc["state_span"]
+            sh = seq_out[c_idx, ss : max(ss + 1, se)]  # [Ls, H]
+            case_state_h.append(sh)
+            case_state_k.append(self.state_k(sh))      # [Ls, H]
+
+        for q_i, qm in enumerate(flat_q_meta):
+            c_idx = qm["_c_idx"]
+            cls_v = seq_out[c_idx, 0]
+            hs, he = qm["hdr_span"]
+            q_hdr_v = seq_out[c_idx, hs : max(hs + 1, he)].mean(dim=0)
+            K = len(qm["option_keys"])
+            sh = case_state_h[c_idx]
+            sk = case_state_k[c_idx]
+
+            om_spans = []
+            ox_spans = []
+            for k_i, (os_i, oe_i) in enumerate(qm["opt_spans"]):
+                sl = seq_out[c_idx, os_i : max(os_i + 1, oe_i)]
+                om_spans.append(sl.mean(dim=0))
+                ox_spans.append(sl.max(dim=0).values)
+            om_stack = torch.stack(om_spans, dim=0)  # [K, H]
+            ox_stack = torch.stack(ox_spans, dim=0)  # [K, H]
+            q_hdr_exp = q_hdr_v.unsqueeze(0).expand(K, H)
+
+            # Query-conditioned state attention per option: [K, H] @ [H, Ls] -> [K, Ls]
+            sq = self.state_q(torch.cat([om_stack, q_hdr_exp], dim=-1))  # [K, H]
+            att_w = F.softmax(torch.matmul(sq, sk.t()) * self.scale_h, dim=-1)
+            s_att = torch.matmul(att_w, sh)  # [K, H]
+
+            opt_mean_t[q_i, :K] = om_stack
+            opt_max_t[q_i, :K] = ox_stack
+            q_hdr_t[q_i, :K] = q_hdr_exp
+            st_att_t[q_i, :K] = s_att
+            cls_t[q_i, :K] = cls_v.unsqueeze(0).expand(K, H)
+            om_t[q_i, :K] = torch.tensor(qm["opt_meta"], dtype=torch.float32, device=device)
+            vk_t[q_i, :K] = True
+            qt_t[q_i] = int(qm["qtype_id"])
+            cid_t[q_i] = int(qm["_case_id"])
+
+        if zs_head_fn is not None and self.zs_dim > 0:
+            blend_h = 0.5 * opt_mean_t + 0.5 * st_att_t
+            zs_logits = zs_head_fn(blend_h).float()  # [Q_tot, max_K, zs_dim]
+            zs_priors = (zs_logits * self.zs_weights.view(1, 1, -1)).sum(dim=-1)
+        else:
+            zs_logits = torch.zeros((Q_tot, max_K, self.zs_dim), dtype=torch.float32, device=device)
+            zs_priors = torch.zeros((Q_tot, max_K), dtype=torch.float32, device=device)
+
+        feats = torch.cat([opt_mean_t, opt_max_t, q_hdr_t, st_att_t, cls_t, zs_logits, om_t], dim=-1)
+        x = self.opt_proj(feats)  # [Q_tot, max_K, comp_dim]
+        x = self.blocks[0](x, vk_t)
+
+        # Ordinal neighbor message passing strictly for `score` scales (is_score == 1)
+        is_score_q = (qt_t == 2).to(x.dtype).view(Q_tot, 1, 1)
+        if max_K > 1:
+            left_nb = torch.cat([x[:, :1, :], x[:, :-1, :]], dim=1)
+            right_nb = torch.cat([x[:, 1:, :], x[:, -1:, :]], dim=1)
+            # Clamp right neighbor at K_q - 1 boundary
+            k_counts = vk_t.sum(dim=1).clamp(min=1)  # [Q_tot]
+            for q_i in range(Q_tot):
+                kq = int(k_counts[q_i].item())
+                if kq < max_K:
+                    right_nb[q_i, kq - 1] = x[q_i, kq - 1]
+            x = x + is_score_q * self.ord_neighbor(torch.cat([x - left_nb, right_nb - x], dim=-1))
+
+        # Cross-question workflow propagation across sibling questions sharing `_case_id`
+        prior_w = F.softmax(zs_priors.masked_fill(~vk_t, -1e4), dim=-1).unsqueeze(-1)
+        q_post = (x * prior_w).sum(dim=1)  # [Q_tot, comp_dim]
         qh = self.wf_norm(q_post)
         D = qh.size(-1)
         nh = 8
         hd = D // nh
-        qkv = self.wf_qkv(qh).view(B, 3, nh, hd)
-        qw = qkv[:, 0].transpose(0, 1)  # [nh, B, hd]
+        qkv = self.wf_qkv(qh).view(Q_tot, 3, nh, hd)
+        qw = qkv[:, 0].transpose(0, 1)
         kw = qkv[:, 1].transpose(0, 1)
         vw = qkv[:, 2].transpose(0, 1)
-        if case_ids is None:
-            same_case = torch.ones((B, B), dtype=torch.bool, device=x.device)
-        else:
-            same_case = case_ids[:, None] == case_ids[None, :]
-        wf_bias = torch.zeros((1, B, B), dtype=x.dtype, device=x.device).masked_fill(~same_case.unsqueeze(0), -1e4)
+        same_case = cid_t[:, None] == cid_t[None, :]
+        wf_bias = torch.zeros((1, Q_tot, Q_tot), dtype=x.dtype, device=device).masked_fill(~same_case.unsqueeze(0), -1e4)
         wf_attn = F.softmax(torch.matmul(qw, kw.transpose(-2, -1)) / math.sqrt(hd) + wf_bias, dim=-1)
-        wf_ctx = torch.matmul(wf_attn, vw).transpose(0, 1).contiguous().view(B, D)
+        wf_ctx = torch.matmul(wf_attn, vw).transpose(0, 1).contiguous().view(Q_tot, D)
         x = x + self.wf_out(wf_ctx).unsqueeze(1)
 
-        x = self.blocks[1](x, valid_k)
+        x = self.blocks[1](x, vk_t)
 
-        # Compute mean and strongest-rival ("max other") representations across valid options
-        vk_f = valid_k.to(x.dtype).unsqueeze(-1)  # [B, K, 1]
+        vk_f = vk_t.to(x.dtype).unsqueeze(-1)
         mean_x = (x * vk_f).sum(dim=1, keepdim=True) / vk_f.sum(dim=1, keepdim=True).clamp(min=1.0)
-
-        # Rival max: for each k, max over j != k among valid options
-        eye = torch.eye(K, dtype=torch.bool, device=x.device).unsqueeze(0)  # [1, K, K]
-        other_valid = valid_k.unsqueeze(1) & (~eye)                         # [B, K, K]
-        x_exp = x.unsqueeze(1).expand(B, K, K, x.size(-1))                  # [B, K, K, D]
+        eye = torch.eye(max_K, dtype=torch.bool, device=device).unsqueeze(0)
+        other_valid = vk_t.unsqueeze(1) & (~eye)
+        x_exp = x.unsqueeze(1).expand(Q_tot, max_K, max_K, D)
         masked_other = x_exp.masked_fill(~other_valid.unsqueeze(-1), -1e4)
         rival_max = masked_other.max(dim=2).values
-        # Fallback if K == 1
         has_other = other_valid.any(dim=2, keepdim=True)
         rival_max = torch.where(has_other, rival_max, mean_x.expand_as(rival_max))
 
         comp_feats = torch.cat([x, x - rival_max, x - mean_x], dim=-1)
-        res_logits = self.out_mlp(comp_feats).squeeze(-1)  # [B, K]
-        logits = nli_priors + res_logits
+        res_logits = self.out_mlp(comp_feats).squeeze(-1)
+        logits = zs_priors + res_logits
 
         if apply_temp:
-            temps = torch.exp(self.log_temps[qtype_ids]).clamp(0.15, 5.0).unsqueeze(-1)
+            temps = torch.exp(self.log_temps[qt_t]).clamp(0.15, 5.0).unsqueeze(-1)
             logits = logits / temps
-        return logits
+        return logits, flat_q_meta
 
 
-QTYPE_TO_ID = {"noul": 0, "choice": 1, "score": 2}
+def encode_case_parallel(
+    tokenizer: Any,
+    state: Any,
+    questions: dict[str, dict[str, Any]],
+    max_state_tokens: int = 3072,
+    case_id: int = 0,
+    precomputed_state_str: str | None = None,
+) -> dict[str, Any]:
+    """Pack State + ALL questions + ALL candidate options into ONE parallel-positioned token sequence."""
+    state_str = precomputed_state_str if precomputed_state_str is not None else compact_state_text(state)
+    cls_id = tokenizer.cls_token_id if tokenizer.cls_token_id is not None else (tokenizer.bos_token_id or 0)
+    sep_id = tokenizer.sep_token_id if tokenizer.sep_token_id is not None else (tokenizer.eos_token_id or 0)
+
+    state_toks = tokenizer.encode("State:\n" + state_str, add_special_tokens=False)
+    if len(state_toks) > max_state_tokens:
+        # Preserve head (derived checks + intro) + tail (late overriding exceptions / final turns)
+        half_h = int(max_state_tokens * 0.55)
+        half_t = max_state_tokens - half_h
+        state_toks = state_toks[:half_h] + state_toks[-half_t:]
+
+    input_ids: list[int] = [cls_id, *state_toks, sep_id]
+    pos_ids: list[int] = list(range(len(input_ids)))
+    q_owner_ids: list[int] = [0] * len(input_ids)
+    opt_branch_ids: list[int] = [0] * len(input_ids)
+    state_span = (1, 1 + len(state_toks))
+    cur_pos = len(input_ids)
+
+    q_records: list[dict[str, Any]] = []
+    for q_idx, (qid, question) in enumerate(questions.items(), start=1):
+        qtype = question["type"]
+        qtype_id = QTYPE_TO_ID.get(qtype, 1)
+        opts = canonical_options(question)
+        K = len(opts)
+        instr = str(question.get("instructions") or "").strip()
+
+        hdr_txt = f"\nQuestion [{qid} | {qtype}]: {instr}\nOptions:"
+        hdr_toks = tokenizer.encode(hdr_txt, add_special_tokens=False)[:192]
+        if not hdr_toks:
+            hdr_toks = [sep_id]
+        hdr_start = len(input_ids)
+        input_ids.extend(hdr_toks)
+        pos_ids.extend(range(cur_pos, cur_pos + len(hdr_toks)))
+        q_owner_ids.extend([q_idx] * len(hdr_toks))
+        opt_branch_ids.extend([0] * len(hdr_toks))
+        hdr_end = len(input_ids)
+        cur_pos += len(hdr_toks)
+
+        # CRITICAL: All options of Question `qid` start at the exact same `opt_base_pos`
+        # AND are isolated in a parallel tree mask (`opt_branch_ids == k_i + 1`) so sibling options
+        # never bleed across identical RoPE coordinates while remaining 100% option-order invariant!
+        opt_base_pos = cur_pos
+        opt_spans: list[tuple[int, int]] = []
+        opt_meta: list[list[float]] = []
+        max_o_len = 1
+
+        is_noul = 1.0 if qtype == "noul" else 0.0
+        is_choice = 1.0 if qtype == "choice" else 0.0
+        is_score = 1.0 if qtype == "score" else 0.0
+        inv_k = 1.0 / max(1, K)
+
+        for k_i, (key, rubric) in enumerate(opts):
+            if qtype == "noul":
+                is_yes = key.lower() in ("true", "yes")
+                verdict = "YES / TRUE" if is_yes else "NO / FALSE"
+                opt_txt = f" [{verdict}: {rubric}]"
+                ord_pos = 1.0 if is_yes else 0.0
+            elif qtype == "score":
+                opt_txt = f" [SCORE {key} of 0..{max(0, K - 1)}: {rubric}]"
+                ord_pos = k_i / max(1, K - 1) if K > 1 else 0.5
+            else:
+                # Strip single-character positional labels (A/B/C/D/0/1) so option relabeling & permutation are invariant
+                clean_k = key.strip()
+                if len(clean_k) > 1 and not clean_k.isdigit() and clean_k.lower() != rubric.strip().lower():
+                    opt_txt = f" [OPTION {clean_k}: {rubric}]"
+                else:
+                    opt_txt = f" [OPTION: {rubric}]"
+                ord_pos = 0.5  # Exact symmetry across all unordered `choice` options!
+
+            o_toks = tokenizer.encode(opt_txt, add_special_tokens=False)[:159] + [sep_id]
+            o_start = len(input_ids)
+            input_ids.extend(o_toks)
+            pos_ids.extend(range(opt_base_pos, opt_base_pos + len(o_toks)))
+            q_owner_ids.extend([q_idx] * len(o_toks))
+            opt_branch_ids.extend([k_i + 1] * len(o_toks))
+            o_end = len(input_ids)
+            opt_spans.append((o_start, o_end))
+            max_o_len = max(max_o_len, len(o_toks))
+            opt_meta.append([ord_pos, ord_pos * ord_pos, is_noul, is_choice, is_score, inv_k])
+
+        q_records.append({
+            "qid": qid,
+            "qsig": question_signature(qid, question),
+            "qtype": qtype,
+            "qtype_id": qtype_id,
+            "option_keys": [k for k, _ in opts],
+            "hdr_span": (hdr_start, hdr_end),
+            "opt_spans": opt_spans,
+            "opt_meta": opt_meta,
+        })
 
+    return {
+        "case_id": case_id,
+        "input_ids": input_ids,
+        "position_ids": pos_ids,
+        "q_owner_ids": q_owner_ids,
+        "opt_branch_ids": opt_branch_ids,
+        "state_span": state_span,
+        "questions": q_records,
+    }
 
-def canonical_options(question: dict[str, Any]) -> list[tuple[str, str]]:
-    """Extract ordered (option_key, rubric_description) pairs for noul, choice, or score."""
-    qtype = question["type"]
-    crit = question.get("criteria")
-    if qtype == "score":
-        return [(str(i), str(desc)) for i, desc in enumerate(crit or [])]
-    if qtype == "noul":
-        cdict = crit if isinstance(crit, dict) else {}
-        return [
-            ("false", str(cdict.get("false") or cdict.get("no") or "False / No: the statement does not hold.")),
-            ("true", str(cdict.get("true") or cdict.get("yes") or "True / Yes: the statement holds based on the state.")),
-        ]
-    if isinstance(crit, dict):
-        return [(str(k), str(v) if v else str(k)) for k, v in crit.items()]
-    opts = question.get("options") or []
-    return [(str(o), str(o)) for o in opts]
 
+def configure_modernbert_full_bidir(backbone: Any, tokenizer: Any | None = None) -> None:
+    """Configure ModernBERT / Ettin for 8,192-token full bidirectional SDPA with custom parallel `position_ids` across HF 4.x & 5.x."""
+    if tokenizer is not None:
+        tokenizer.model_max_length = 8192
+    cfg = getattr(backbone, "config", None)
+    if cfg is not None:
+        cfg.local_attention = 16384
+        cfg.sliding_window = 16384
+        cfg.global_attn_every_n_layers = 1
+        cfg._attn_implementation = "sdpa"
+        cfg.reference_compile = False
+        if hasattr(cfg, "layer_types") and isinstance(cfg.layer_types, list):
+            cfg.layer_types = ["full_attention"] * len(cfg.layer_types)
+    enc_model = getattr(backbone, "model", None)
+    for layer in getattr(enc_model, "layers", []):
+        if hasattr(layer, "attention_type"):
+            layer.attention_type = "full_attention"
+        attn_mod = getattr(layer, "attn", None)
+        if attn_mod is not None and hasattr(attn_mod, "local_attention"):
+            attn_mod.local_attention = (-1, -1)
+
+
+def build_parallel_tree_mask(
+    q_t: torch.Tensor,
+    o_t: torch.Tensor,
+    dtype: torch.dtype,
+    return_bool: bool = False,
+) -> torch.Tensor:
+    """Build exact `[B, 1, L, L]` parallel-option tree mask:
+      - State & Question Headers (`o_t == 0`) attend freely to State & Question Headers (`o_t == 0`), never options.
+      - Each Option `(q, k)` (`o_t > 0`) attends to State (`q_t == 0`), its own Question Header `q` (`q_t == q, o_t == 0`),
+        and ITSELF (`q_t == q, o_t == k`), strictly eliminating cross-option RoPE collision!
+    """
+    valid = q_t >= 0
+    is_opt_q = o_t[:, :, None] > 0
+    allow_non_opt = o_t[:, None, :] == 0
+    same_q = q_t[:, None, :] == q_t[:, :, None]
+    allow_opt = (q_t[:, None, :] == 0) | (same_q & ((o_t[:, None, :] == 0) | (o_t[:, None, :] == o_t[:, :, None])))
+    allow = valid[:, :, None] & valid[:, None, :] & torch.where(is_opt_q, allow_opt, allow_non_opt)
+    if return_bool:
+        return allow.unsqueeze(1)
+    neg_val = -1e4 if dtype in (torch.float16, torch.bfloat16) else -1e9
+    mask_4d = torch.zeros(allow.shape, dtype=dtype, device=q_t.device).masked_fill(~allow, neg_val)
+    return mask_4d.unsqueeze(1)
+
+
+def forward_parallel_backbone(
+    backbone: Any,
+    packed_cases: list[dict[str, Any]],
+    pad_id: int,
+    device: str,
+    amp_dtype: torch.dtype = torch.float32,
+) -> tuple[torch.Tensor, Any]:
+    """Run ONE batched forward pass of ModernBERT across `B` packed multi-question cases with exact parallel tree isolation."""
+    raw_max_L = max(len(pc["input_ids"]) for pc in packed_cases)
+    pad_L = max(32, ((raw_max_L + 31) // 32) * 32)
+
+    ids_cpu = [pc["input_ids"] + [pad_id] * (pad_L - len(pc["input_ids"])) for pc in packed_cases]
+    pos_cpu = [pc["position_ids"] + [0] * (pad_L - len(pc["position_ids"])) for pc in packed_cases]
+    qow_cpu = [pc["q_owner_ids"] + [-1] * (pad_L - len(pc["q_owner_ids"])) for pc in packed_cases]
+    obr_cpu = [pc["opt_branch_ids"] + [-1] * (pad_L - len(pc["opt_branch_ids"])) for pc in packed_cases]
+
+    ids_t = torch.tensor(ids_cpu, dtype=torch.long, device=device)
+    pos_t = torch.tensor(pos_cpu, dtype=torch.long, device=device)
+    qow_t = torch.tensor(qow_cpu, dtype=torch.long, device=device)
+    obr_t = torch.tensor(obr_cpu, dtype=torch.long, device=device)
+
+    use_amp = (device == "cuda") and (amp_dtype in (torch.bfloat16, torch.float16))
+    mask_dt = amp_dtype if use_amp else next(backbone.parameters()).dtype
+    if hasattr(backbone, "model"):
+        m = backbone.model
+        is_hf4 = "sliding_window_mask" in inspect.signature(m.forward).parameters
+        tree_mask = build_parallel_tree_mask(qow_t, obr_t, dtype=mask_dt, return_bool=not is_hf4)
+        with torch.amp.autocast("cuda", dtype=amp_dtype, enabled=use_amp):
+            if is_hf4:
+                hidden_states = m.embeddings(input_ids=ids_t)
+                for encoder_layer in m.layers:
+                    layer_outputs = encoder_layer(
+                        hidden_states,
+                        attention_mask=tree_mask,
+                        sliding_window_mask=tree_mask,
+                        position_ids=pos_t,
+                    )
+                    hidden_states = layer_outputs[0]
+                seq_f = m.final_norm(hidden_states).float()
+            else:
+                enc_out = m(
+                    input_ids=ids_t,
+                    attention_mask={"full_attention": tree_mask, "sliding_attention": tree_mask},
+                    position_ids=pos_t,
+                )
+                seq_f = enc_out.last_hidden_state.float()
 
-def build_hypothesis_text(
-    qid: str,
-    question: dict[str, Any],
-    opt_idx: int,
-    opts: list[tuple[str, str]],
-    peer_q_summary: str = "",
-) -> str:
-    qtype = question["type"]
-    instr = str(question.get("instructions") or "").strip()
-    key, rubric = opts[opt_idx]
-    K = len(opts)
-    others = [f"{ok}" for idx, (ok, _) in enumerate(opts) if idx != opt_idx]
-    others_s = ", ".join(others[:8])
-    if qtype == "noul":
-        verdict = "YES / TRUE" if key in ("true", "yes") else "NO / FALSE"
-        base = f"Decision [{qid} · yes/no]: {instr}\nHypothesis ({verdict}): {rubric}"
-    elif qtype == "score":
-        base = (
-            f"Ordinal Rating [{qid} · level {key} of 0..{K-1}]: {instr}\n"
-            f"Hypothesis (Level {key}): {rubric}"
-        )
+        def zs_fn(h_tensor: torch.Tensor) -> torch.Tensor:
+            with torch.amp.autocast("cuda", dtype=amp_dtype, enabled=use_amp):
+                in_dt = next(backbone.head.parameters()).dtype
+                return backbone.classifier(backbone.head(h_tensor.to(in_dt))).float()
+
+        return seq_f, zs_fn
+
+    # Generic fallback for non-ModernBERT encoders
+    att_t = (qow_t >= 0).long()
+    with torch.amp.autocast("cuda", dtype=amp_dtype, enabled=use_amp):
+        out = backbone(input_ids=ids_t, attention_mask=att_t, position_ids=pos_t, output_hidden_states=True)
+        seq_f = out.hidden_states[-1].float()
+    return seq_f, None
+
+
+# --- Legacy v2.0 LoRA & Pairwise Helpers Retained for Backward Compatibility ---
+
+
+class LoRALinear(nn.Module):
+    """Rank-r LoRA wrapper preserving frozen base nn.Linear weights."""
+
+    def __init__(self, base: nn.Linear, r: int = 16, alpha: float = 32.0, dropout: float = 0.05) -> None:
+        super().__init__()
+        self.base = base
+        for p in self.base.parameters():
+            p.requires_grad = False
+        self.r = r
+        self.scale = alpha / r
+        self.drop = nn.Dropout(dropout)
+        self.lora_A = nn.Parameter(torch.empty(r, base.in_features))
+        self.lora_B = nn.Parameter(torch.zeros(base.out_features, r))
+        nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        orig_dtype = x.dtype
+        out = self.base(x.to(self.base.weight.dtype))
+        lora_delta = (self.drop(x.to(self.lora_A.dtype)) @ self.lora_A.t() @ self.lora_B.t()) * self.scale
+        return out.to(orig_dtype) + lora_delta.to(orig_dtype)
+
+
+def inject_encoder_lora(backbone: nn.Module, start_layer: int = 8, r: int = 16, alpha: float = 32.0) -> list[str]:
+    """Inject LoRA adapters into DeBERTa-v3 or ELECTRA/BERT encoder layers from `start_layer` up."""
+    wrapped: list[str] = []
+    if hasattr(backbone, "deberta"):
+        layers = backbone.deberta.encoder.layer
+    elif hasattr(backbone, "encoder") and hasattr(backbone.encoder, "layer"):
+        layers = backbone.encoder.layer
     else:
-        base = (
-            f"Choice [{qid} · 1 of {K} ({key} vs {others_s})]: {instr}\n"
-            f"Hypothesis ({key}): {rubric}"
-        )
-    if peer_q_summary:
-        base = f"{base}\nWorkflow context: {peer_q_summary}"
-    return base
-
-
-_FOCUS_STOP = {
-    "the", "and", "for", "with", "that", "this", "from", "are", "was", "were", "has", "have",
-    "had", "not", "but", "what", "which", "who", "whom", "when", "where", "why", "how", "does",
-    "did", "can", "could", "should", "would", "will", "into", "onto", "upon", "over", "under",
-    "based", "state", "given", "select", "choose", "rate", "level", "option", "true", "false",
-    "yes", "statement", "holds", "whether", "strictly", "provided", "rubric", "criteria",
-}
-
-
-def focus_state_for_question(
-    state_str: str,
-    qid: str,
-    question: dict[str, Any],
-    opts: list[tuple[str, str]],
-    max_chars: int = 1480,
-) -> str:
-    """Preserve Head (derived checks + intro) + Query-Matched Middle Clauses + Tail (late turns/exceptions)."""
-    if len(state_str) <= max_chars:
-        return state_str
-
-    head_budget = 460
-    tail_budget = 440
-    mid_budget = max(240, max_chars - head_budget - tail_budget - 30)
-
-    head_part = state_str[:head_budget]
-    nl_h = head_part.rfind("\n")
-    if nl_h >= 260:
-        head_part = head_part[:nl_h]
-
-    tail_part = state_str[-tail_budget:]
-    nl_t = tail_part.find("\n")
-    if 0 <= nl_t <= 160:
-        tail_part = tail_part[nl_t + 1 :]
-
-    mid_region = state_str[len(head_part) : max(len(head_part), len(state_str) - len(tail_part))].strip()
-    if not mid_region:
-        return f"{head_part}\n...\n{tail_part}"
-
-    q_blob = f"{qid} {question.get('instructions', '')} " + " ".join(f"{k} {r}" for k, r in opts)
-    q_stems = {
-        w[:5] if len(w) >= 6 else w.rstrip("s")
-        for w in re.findall(r"[a-z0-9]{3,}", q_blob.lower())
-        if w not in _FOCUS_STOP
-    }
-    chunks = [c.strip() for c in re.split(r"(?<=[.!?\n])\s+", mid_region) if c.strip()]
-    if not chunks:
-        return f"{head_part}\n...\n{tail_part}"
-
-    scored: list[tuple[float, int, str]] = []
-    for idx, ch in enumerate(chunks):
-        cl = ch.lower()
-        hits = sum(1.0 for st in q_stems if st and st in cl)
-        # Boost explicit exception/override/negation/threshold clauses in long policies & traces
-        if any(kw in cl for kw in ("except", "unless", "override", "carveout", "however", "critical", "error", "fail", "breach", "null", "missing")):
-            hits += 0.85
-        scored.append((hits, idx, ch))
-
-    scored.sort(key=lambda x: (x[0], -abs(x[1] - len(chunks) // 2)), reverse=True)
-    picked_idx: list[int] = []
-    used = 0
-    for sc, idx, ch in scored:
-        if used + len(ch) + 2 > mid_budget and picked_idx:
-            continue
-        picked_idx.append(idx)
-        used += len(ch) + 2
-        if used >= mid_budget:
-            break
+        raise ValueError(f"Unsupported encoder architecture: {type(backbone)}")
 
-    picked_idx.sort()
-    mid_selected = "\n".join(chunks[i] for i in picked_idx)
-    return f"{head_part}\n[...]\n{mid_selected}\n[...]\n{tail_part}"
+    for idx in range(start_layer, len(layers)):
+        blk = layers[idx]
+        attn_self = blk.attention.self
+        for attr in ("query_proj", "key_proj", "value_proj", "query", "key", "value"):
+            if hasattr(attn_self, attr):
+                orig = getattr(attn_self, attr)
+                if isinstance(orig, nn.Linear):
+                    setattr(attn_self, attr, LoRALinear(orig, r=r, alpha=alpha))
+                    wrapped.append(f"layer.{idx}.attention.self.{attr}")
+        if hasattr(blk.attention, "output") and isinstance(blk.attention.output.dense, nn.Linear):
+            blk.attention.output.dense = LoRALinear(blk.attention.output.dense, r=r, alpha=alpha)
+            wrapped.append(f"layer.{idx}.attention.output.dense")
+        if hasattr(blk, "intermediate") and isinstance(blk.intermediate.dense, nn.Linear):
+            blk.intermediate.dense = LoRALinear(blk.intermediate.dense, r=r, alpha=alpha)
+            wrapped.append(f"layer.{idx}.intermediate.dense")
+        if hasattr(blk, "output") and isinstance(blk.output.dense, nn.Linear):
+            blk.output.dense = LoRALinear(blk.output.dense, r=r, alpha=alpha)
+            wrapped.append(f"layer.{idx}.output.dense")
+    return wrapped
 
 
-def encode_decision_question(
-    tokenizer: Any,
-    state: Any,
-    qid: str,
-    question: dict[str, Any],
-    peer_q_summary: str = "",
-    max_length: int = 512,
-    precomputed_state_str: str | None = None,
-) -> dict[str, Any]:
-    """Encode all K candidate options for one question as Premise=FocusedState, Hypothesis=Option_k."""
-    opts = canonical_options(question)
-    qtype = question["type"]
-    K = len(opts)
-    raw_state_str = precomputed_state_str if precomputed_state_str is not None else compact_state_text(state)
-    state_str = focus_state_for_question(raw_state_str, qid, question, opts, max_chars=max(950, int(max_length * 2.9)))
-
-    pair_ids: list[list[int]] = []
-    pair_attn: list[list[int]] = []
-    pair_prem: list[list[float]] = []
-    pair_hyp: list[list[float]] = []
-    opt_meta: list[list[float]] = []
-
-    is_score = 1.0 if qtype == "score" else 0.0
-    inv_k = 1.0 / max(1, K)
-
-    for k_i in range(K):
-        hyp = build_hypothesis_text(qid, question, k_i, opts, peer_q_summary=peer_q_summary)
-        enc = tokenizer(
-            state_str,
-            hyp,
-            truncation="only_first",
-            max_length=max_length,
-        )
-        ids = enc["input_ids"]
-        seq_ids = enc.sequence_ids()
-        L = len(ids)
-        pm = [1.0 if s == 0 else 0.0 for s in seq_ids]
-        hm = [1.0 if s == 1 else 0.0 for s in seq_ids]
-        if sum(hm) == 0.0:
-            hm[0] = 1.0
-        pair_ids.append(ids)
-        pair_attn.append(enc["attention_mask"])
-        pair_prem.append(pm)
-        pair_hyp.append(hm)
-        npos = k_i / max(1, K - 1) if K > 1 else 0.5
-        opt_meta.append([npos, npos * npos, is_score, inv_k])
+class CrossOptionDecisionHead(nn.Module):
+    """v2.0 Pairwise Residual NLI-Prior + 2-Layer Cross-Option Competition Scorer (legacy support)."""
 
-    return {
-        "qid": qid,
-        "qtype": qtype,
-        "qtype_id": QTYPE_TO_ID.get(qtype, 1),
-        "option_keys": [k for k, _ in opts],
-        "pair_ids": pair_ids,
-        "pair_attn": pair_attn,
-        "pair_prem": pair_prem,
-        "pair_hyp": pair_hyp,
-        "opt_meta": opt_meta,
-    }
+    def __init__(self, hidden_size: int = 1024, comp_dim: int = 512, dropout: float = 0.1) -> None:
+        super().__init__()
+        self.pair_proj = nn.Sequential(
+            nn.Linear(hidden_size * 3 + 7, comp_dim),
+            nn.LayerNorm(comp_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+        )
+        self.prem_q = nn.Linear(hidden_size, hidden_size)
+        self.prem_k = nn.Linear(hidden_size, hidden_size)
+        self.scale_h = 1.0 / math.sqrt(hidden_size)
+        self.blocks = nn.ModuleList([
+            CrossOptionBlock(dim=comp_dim, num_heads=8, dropout=dropout),
+            CrossOptionBlock(dim=comp_dim, num_heads=8, dropout=dropout),
+        ])
+        self.wf_norm = nn.LayerNorm(comp_dim)
+        self.wf_qkv = nn.Linear(comp_dim, comp_dim * 3)
+        self.wf_out = nn.Linear(comp_dim, comp_dim)
+        self.out_mlp = nn.Sequential(
+            nn.Linear(comp_dim * 3, comp_dim // 2),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(comp_dim // 2, 1),
+        )
+        self.nli_weights = nn.Parameter(torch.tensor([0.75, -0.10, -0.65], dtype=torch.float32))
+        self.log_temps = nn.Parameter(torch.zeros(3, dtype=torch.float32))
 
 
 class NullspanSystemOneEngine:
-    """Unified System One inference engine supporting `/v1/systemone` for Typed Decisions & JevBench."""
+    """Unified System One v3.0 inference engine supporting `/v1/systemone` for Typed Decisions & JevBench."""
 
     def __init__(
         self,
         nli_backbone: Any,
         tokenizer: Any,
-        head: CrossOptionDecisionHead,
+        head: nn.Module,
         device: str = "cpu",
-        max_length: int = 512,
+        max_length: int = 3072,
+        arch_version: int = 3,
     ) -> None:
         self.nli_backbone = nli_backbone
         self.tokenizer = tokenizer
         self.head = head
         self.device = device
         self.max_length = max_length
+        self.arch_version = arch_version
+        self.schema_calib: dict[str, dict[str, Any]] = {}
+        if arch_version >= 3:
+            configure_modernbert_full_bidir(self.nli_backbone, self.tokenizer)
+        self.amp_dtype = (
+            torch.bfloat16
+            if (device == "cuda" and torch.cuda.get_device_capability(0)[0] >= 8)
+            else (torch.float16 if device == "cuda" else torch.float32)
+        )
         self.nli_backbone.to(device).eval()
-        if device == "cuda" and torch.cuda.get_device_capability(0)[0] >= 8 and hasattr(self.nli_backbone, "deberta"):
-            self.nli_backbone.deberta.to(torch.bfloat16)
+        if device == "cuda" and arch_version == 3:
+            self.nli_backbone.to(self.amp_dtype)
         self.head.to(device).eval()
 
     @classmethod
@@ -713,7 +1020,7 @@ class NullspanSystemOneEngine:
         device: str | None = None,
         revision: str | None = None,
     ) -> "NullspanSystemOneEngine":
-        from transformers import AutoModelForSequenceClassification, AutoTokenizer
+        from transformers import AutoConfig, AutoModelForSequenceClassification, AutoTokenizer
 
         if device is None:
             if torch.cuda.is_available():
@@ -735,146 +1042,128 @@ class NullspanSystemOneEngine:
         s1_dir = os.path.join(model_dir, "systemone")
         ckpt_path = os.path.join(model_dir, "systemone_decision.pt")
         ckpt = torch.load(ckpt_path, map_location="cpu", weights_only=True)
+        arch_version = int(ckpt.get("arch_version", 2))
         backbone_src = s1_dir if os.path.isdir(s1_dir) else ckpt.get(
-            "backbone_id", "MoritzLaurer/DeBERTa-v3-large-mnli-fever-anli-ling-wanli"
+            "backbone_id", "MoritzLaurer/ModernBERT-large-zeroshot-v2.0"
         )
 
-        tok = AutoTokenizer.from_pretrained(backbone_src)
-        nli_model = AutoModelForSequenceClassification.from_pretrained(backbone_src)
-        if ckpt.get("lora_r", 0) > 0:
-            inject_encoder_lora(
-                nli_model,
-                start_layer=int(ckpt.get("start_layer", 6)),
-                r=int(ckpt["lora_r"]),
-                alpha=float(ckpt.get("lora_alpha", 32.0)),
+        cfg_json_path = os.path.join(backbone_src, "config.json") if os.path.isdir(backbone_src) else ""
+        if cfg_json_path and os.path.isfile(cfg_json_path):
+            with open(cfg_json_path, "r", encoding="utf-8") as cf:
+                raw_cfg = json.load(cf)
+            if raw_cfg.get("model_type") == "modernbert" and raw_cfg.get("global_attn_every_n_layers") == 1:
+                raw_cfg["global_attn_every_n_layers"] = 3
+                raw_cfg["local_rope_theta"] = float(raw_cfg.get("global_rope_theta", 160000.0))
+                raw_cfg.pop("sliding_window", None)
+                from transformers import ModernBertConfig
+                bb_cfg = ModernBertConfig(**raw_cfg)
+            else:
+                bb_cfg = AutoConfig.from_pretrained(backbone_src)
+        else:
+            bb_cfg = AutoConfig.from_pretrained(backbone_src)
+        tok = AutoTokenizer.from_pretrained(backbone_src, config=bb_cfg)
+        if arch_version >= 3:
+            bb_cfg.reference_compile = False
+            bb_cfg._attn_implementation = "sdpa"
+            bb_cfg.local_attention = 16384
+            bb_cfg.global_attn_every_n_layers = 1
+            if hasattr(bb_cfg, "layer_types"):
+                bb_cfg.layer_types = ["full_attention"] * int(bb_cfg.num_hidden_layers)
+        nli_model = AutoModelForSequenceClassification.from_pretrained(backbone_src, config=bb_cfg)
+        hidden_size = int(nli_model.config.hidden_size)
+
+        if arch_version >= 3:
+            zs_dim = int(ckpt.get("zs_dim", int(getattr(nli_model.config, "num_labels", 2))))
+            head: nn.Module = ParallelSpanDecisionHead(
+                hidden_size=hidden_size,
+                comp_dim=int(ckpt.get("comp_dim", 512)),
+                zs_dim=zs_dim,
+                dropout=0.0,
+            )
+            head.load_state_dict(ckpt["head_state_dict"], strict=False)
+            max_len = int(ckpt.get("max_state_tokens", 3072))
+        else:
+            if ckpt.get("lora_r", 0) > 0:
+                inject_encoder_lora(
+                    nli_model,
+                    start_layer=int(ckpt.get("start_layer", 6)),
+                    r=int(ckpt["lora_r"]),
+                    alpha=float(ckpt.get("lora_alpha", 32.0)),
+                )
+                nli_model.load_state_dict(ckpt["lora_state_dict"], strict=False)
+            if "classifier_state_dict" in ckpt:
+                nli_model.load_state_dict(ckpt["classifier_state_dict"], strict=False)
+            head = CrossOptionDecisionHead(
+                hidden_size=hidden_size,
+                comp_dim=int(ckpt.get("comp_dim", 512)),
+                dropout=0.0,
             )
-            nli_model.load_state_dict(ckpt["lora_state_dict"], strict=False)
-        if "classifier_state_dict" in ckpt:
-            nli_model.load_state_dict(ckpt["classifier_state_dict"], strict=False)
+            head.load_state_dict(ckpt["head_state_dict"])
+            max_len = min(512, int(ckpt.get("max_length", 512)))
 
-        hidden_size = int(nli_model.config.hidden_size)
-        head = CrossOptionDecisionHead(
-            hidden_size=hidden_size,
-            comp_dim=int(ckpt.get("comp_dim", 512)),
-            dropout=0.0,
-        )
-        head.load_state_dict(ckpt["head_state_dict"])
-        return cls(
+        eng = cls(
             nli_backbone=nli_model,
             tokenizer=tok,
             head=head,
             device=device,
-            max_length=min(512, int(ckpt.get("max_length", 512))),
+            max_length=max_len,
+            arch_version=arch_version,
         )
+        eng.schema_calib = dict(ckpt.get("schema_calib") or {})
+        return eng
 
     @torch.no_grad()
     def decide(self, state: Any, questions: dict[str, dict[str, Any]], max_length: int | None = None) -> dict[str, Any]:
-        max_len = max_length or self.max_length
-        qids = list(questions.keys())
+        max_state_toks = max_length or self.max_length
         state_str = compact_state_text(state)
-        peer_summary = ", ".join(f"{qk}({questions[qk].get('type')})" for qk in qids) if len(qids) > 1 else ""
-
-        encoded_qs = [
-            encode_decision_question(
-                self.tokenizer,
-                state,
-                qid,
-                questions[qid],
-                peer_q_summary=peer_summary,
-                max_length=max_len,
-                precomputed_state_str=state_str,
-            )
-            for qid in qids
-        ]
-
-        # Flatten all pairs across all questions into ONE single parallel GPU batch
-        flat_ids: list[list[int]] = []
-        flat_attn: list[list[int]] = []
-        flat_prem: list[list[float]] = []
-        flat_hyp: list[list[float]] = []
-        q_slices: list[tuple[int, int]] = []
-
-        for eq in encoded_qs:
-            s_i = len(flat_ids)
-            flat_ids.extend(eq["pair_ids"])
-            flat_attn.extend(eq["pair_attn"])
-            flat_prem.extend(eq["pair_prem"])
-            flat_hyp.extend(eq["pair_hyp"])
-            q_slices.append((s_i, len(flat_ids)))
-
-        P = len(flat_ids)
-        raw_max_L = max(len(x) for x in flat_ids)
-        pad_L = min(max_len, max(64, ((raw_max_L + 31) // 32) * 32))
+        pc = encode_case_parallel(
+            self.tokenizer,
+            state,
+            questions,
+            max_state_tokens=max_state_toks,
+            case_id=0,
+            precomputed_state_str=state_str,
+        )
         pad_id = self.tokenizer.pad_token_id or 0
+        seq_f, zs_fn = forward_parallel_backbone(
+            self.nli_backbone,
+            [pc],
+            pad_id=pad_id,
+            device=self.device,
+            amp_dtype=self.amp_dtype,
+        )
+        assert isinstance(self.head, ParallelSpanDecisionHead)
+        raw_logits, flat_q_meta = self.head.forward_packed_cases(seq_f, [pc], zs_head_fn=zs_fn, apply_temp=False)
 
-        ids_cpu = [ids[:pad_L] + [pad_id] * (pad_L - min(len(ids), pad_L)) for ids in flat_ids]
-        attn_cpu = [at[:pad_L] + [0] * (pad_L - min(len(at), pad_L)) for at in flat_attn]
-        prem_cpu = [pm[:pad_L] + [0.0] * (pad_L - min(len(pm), pad_L)) for pm in flat_prem]
-        hyp_cpu = [hm[:pad_L] + [0.0] * (pad_L - min(len(hm), pad_L)) for hm in flat_hyp]
-
-        ids_t = torch.tensor(ids_cpu, dtype=torch.long, device=self.device)
-        attn_t = torch.tensor(attn_cpu, dtype=torch.long, device=self.device)
-        prem_t = torch.tensor(prem_cpu, dtype=torch.float32, device=self.device)
-        hyp_t = torch.tensor(hyp_cpu, dtype=torch.float32, device=self.device)
-
-        seq_chunks: list[torch.Tensor] = []
-        nli_chunks: list[torch.Tensor] = []
-        for c_s in range(0, P, 24):
-            ids_c = ids_t[c_s : c_s + 24]
-            attn_c = attn_t[c_s : c_s + 24]
-            if hasattr(self.nli_backbone, "deberta"):
-                enc_out = self.nli_backbone.deberta(input_ids=ids_c, attention_mask=attn_c)
-                seq_c = enc_out.last_hidden_state.float()
-                pooled_c = self.nli_backbone.pooler(seq_c)
-                nli_c = self.nli_backbone.classifier(pooled_c).float()
-            else:
-                out = self.nli_backbone(input_ids=ids_c, attention_mask=attn_c, output_hidden_states=True)
-                seq_c = out.hidden_states[-1].float()
-                nli_c = out.logits.float()
-            seq_chunks.append(seq_c)
-            nli_chunks.append(nli_c)
-        seq_f = torch.cat(seq_chunks, dim=0)
-        nli_f = torch.cat(nli_chunks, dim=0)
-        pair_vecs_flat, nli_priors_flat = self.head.pool_pair_features(seq_f, nli_f, prem_t, hyp_t)
-
-        B = len(encoded_qs)
-        max_K = max(len(eq["option_keys"]) for eq in encoded_qs)
-        feat_dim = pair_vecs_flat.size(-1)
-
-        pv_g = torch.zeros((B, max_K, feat_dim), dtype=torch.float32, device=self.device)
-        nl_g = torch.zeros((B, max_K, 3), dtype=torch.float32, device=self.device)
-        np_g = torch.zeros((B, max_K), dtype=torch.float32, device=self.device)
-        om_g = torch.zeros((B, max_K, 4), dtype=torch.float32, device=self.device)
-        vk_g = torch.zeros((B, max_K), dtype=torch.bool, device=self.device)
-        qt_g = torch.zeros((B,), dtype=torch.long, device=self.device)
-
-        for b_i, eq in enumerate(encoded_qs):
-            s_i, e_i = q_slices[b_i]
-            K = e_i - s_i
-            pv_g[b_i, :K] = pair_vecs_flat[s_i:e_i]
-            nl_g[b_i, :K] = nli_f[s_i:e_i]
-            np_g[b_i, :K] = nli_priors_flat[s_i:e_i]
-            om_g[b_i, :K] = torch.tensor(eq["opt_meta"], dtype=torch.float32, device=self.device)
-            vk_g[b_i, :K] = True
-            qt_g[b_i] = eq["qtype_id"]
-
-        logits = self.head.score_grouped_options(pv_g, nl_g, np_g, om_g, vk_g, qt_g, apply_temp=True)
-
-        # Estimate realistic input tokens (state + questions once, not Kx duplicated)
-        approx_state_toks = len(self.tokenizer.encode(state_str, add_special_tokens=False))
-        approx_q_toks = sum(45 * len(eq["option_keys"]) for eq in encoded_qs)
-        total_in_toks = approx_state_toks + approx_q_toks
-
+        total_in_toks = len(pc["input_ids"])
         answers: dict[str, Any] = {}
-        for b_i, qid in enumerate(qids):
-            eq = encoded_qs[b_i]
-            keys = eq["option_keys"]
+
+        for b_i, qm in enumerate(flat_q_meta):
+            qid = qm["qid"]
+            qsig = qm.get("qsig", "")
+            keys = qm["option_keys"]
             K = len(keys)
-            probs_t = F.softmax(logits[b_i, :K], dim=-1).cpu().tolist()
-            s_p = sum(probs_t)
-            probs = [p / s_p for p in probs_t]
+            qtype = qm["qtype"]
+            qt_id = int(qm["qtype_id"])
+            lv = raw_logits[b_i, :K].float().cpu()
+            sc = self.schema_calib.get(qsig)
+            if sc is not None:
+                t_q = max(0.25, float(sc.get("temp", 1.0)))
+                b_map = sc.get("bias") or {}
+                b_vec = torch.tensor([float(b_map.get(k, 0.0)) for k in keys], dtype=torch.float32)
+                lv = lv / t_q + b_vec
+            else:
+                t_g = float(torch.exp(self.head.log_temps[qt_id]).clamp(0.15, 5.0).item())
+                lv = lv / t_g
+            probs_raw = F.softmax(lv, dim=-1).tolist()
+            smooth_eps = float(sc.get("smooth", self.head.prob_smooth[qt_id].item())) if sc is not None else float(self.head.prob_smooth[qt_id].item())
+            if smooth_eps > 0.0:
+                u = 1.0 / max(1, K)
+                probs_raw = [(1.0 - smooth_eps) * p + smooth_eps * u for p in probs_raw]
+            s_p = sum(probs_raw)
+            probs = [p / s_p for p in probs_raw]
             best_idx = max(range(K), key=lambda idx: probs[idx])
-            qtype = eq["qtype"]
+
             if qtype == "noul":
                 p_true = float(probs[keys.index("true")]) if "true" in keys else float(probs[-1])
                 p_true_r = round(min(1.0, max(0.0, p_true)), 6)