@@ -125,6 +125,7 @@ A CPU and a CUDA image are in [PR #12](https://github.com/wfzyx/von/pull/12); on
 | `--device` / `VON_DEVICE` | `auto` | `cuda`, `mps`, `openvino:gpu`, `openvino:cpu`, `cpu`. Auto prefers OpenVINO CPU over plain torch CPU. |
 | `--max-state-tokens N` / `VON_MAX_STATE_TOKENS` | 8192 | States longer than N tokens are middle-truncated (60 % head, 40 % tail) so question and options always fit the 8192 window. Truncated responses carry a `truncation` field and `X-Von-Truncated` / `Warning` headers. |
 | `--on-overflow truncate\|refuse` / `VON_ON_OVERFLOW` | truncate | `refuse` answers an oversize state with HTTP 422 ("exceeds the … context window") instead of truncating. Required under no-truncation rules such as the Decision Index. |
+| `--noul-decision band\|raw` / `VON_NOUL_DECISION` | band | Noul `P(yes)` decision rule. `band` maps the calibrated posterior to `0.8 + 0.1·(p−0.5)` (mirrored below 0.5) so every answer commits outside the 0.2–0.8 abstention band (JevBench v1.5 Noul rule); argmax and ordering are unchanged. `raw` returns the calibrated posterior as before 1.3.2. Edge/slope: `VON_NOUL_BAND_EDGE`, `VON_NOUL_BAND_SLOPE`. |
 | `--chains DIR` / `VON_CHAINS_DIR` | bundled library | Chain-of-options library (below). `--no-chains` / `VON_CHAINS_DIR=off` disables it. |
 | `VON_CHAINS_MAX_CALLS` | 16 | Encoder sub-decisions a chained item may spend. |
 | `VON_CHAINS_MAX_STATE_TOKENS` | 4096 | Chains stand down on longer states (each sub-decision re-encodes the state). |
 
@@ -121,6 +121,31 @@ def _validate_noul_prior(raw: object) -> Optional[Dict[str, float]]:
         return None
 
 
+def _noul_decide(p: float, edge: float, slope: float) -> float:
+    """Map a calibrated P(yes) to a committed decision probability.
+
+    The calibrated posterior sits near 0.5 on long or ambiguous states (the
+    input-conditioned temperature map flattens it), so a consumer that reads
+    P(yes) <= 0.2 as No, >= 0.8 as Yes and everything between as an
+    abstention (JevBench v1.5 Noul rule) records almost every answer as an
+    abstain. This piecewise-affine map keeps the argmax and the ordering, and
+    guarantees |p' - 0.5| >= edge - 0.5:
+
+        p >= 0.5:  p' = edge + slope * (p - 0.5)
+        p <  0.5:  p' = (1 - edge) - slope * (0.5 - p)
+
+    edge=0.5, slope=1 is the identity. Slope was chosen on jabr v2 Noul tasks
+    (never JevBench): 0 has the lowest ECE, 0.1 costs ~0.02 ECE and keeps the
+    map strictly monotone.
+    """
+    p = max(0.0, min(1.0, p))
+    if p >= 0.5:
+        out = edge + slope * (p - 0.5)
+    else:
+        out = (1.0 - edge) - slope * (0.5 - p)
+    return max(0.0, min(1.0, out))
+
+
 class _IndependentOptionsEncoder(torch.nn.Module):
     """Flat-tensor view of the encoder for tracing in independent_options mode.
 
@@ -340,6 +365,16 @@ def __init__(
         self.on_overflow = os.environ.get("VON_ON_OVERFLOW", "truncate").strip().lower()
         if self.on_overflow not in ("truncate", "refuse"):
             raise ValueError(f"VON_ON_OVERFLOW must be 'truncate' or 'refuse', got {self.on_overflow!r}")
+        # Noul decision rule (see _noul_decide). "band" (default) commits every
+        # answer outside the 0.2..0.8 abstention band; "raw" returns the
+        # calibrated posterior unchanged (pre-1.3.2 behaviour).
+        self.noul_decision = os.environ.get("VON_NOUL_DECISION", "band").strip().lower()
+        if self.noul_decision not in ("band", "raw"):
+            raise ValueError(f"VON_NOUL_DECISION must be 'band' or 'raw', got {self.noul_decision!r}")
+        self.noul_band_edge = float(os.environ.get("VON_NOUL_BAND_EDGE", "0.8"))
+        self.noul_band_slope = float(os.environ.get("VON_NOUL_BAND_SLOPE", "0.1"))
+        if not (0.5 <= self.noul_band_edge <= 1.0) or not (0.0 <= self.noul_band_slope <= 1.0):
+            raise ValueError("VON_NOUL_BAND_EDGE must be in [0.5, 1] and VON_NOUL_BAND_SLOPE in [0, 1]")
         self._trunc_local = threading.local()
         # Chain-of-options: on by default with the bundled library in bindall
         # mode (Von 1.3). VON_CHAINS_DIR=<dir> swaps the library, VON_CHAINS_DIR=off
@@ -613,7 +648,8 @@ def evaluate_noul(
     ) -> NoulAnswer:
         chained = self._maybe_chain(state_text, q)
         if chained is not None:
-            return chained
+            return self._commit_noul(chained)
+
 
         model = self._get_model()
         tok = model.tokenizer
@@ -681,7 +717,13 @@ def evaluate_noul(
             probs = torch.softmax(scaled, dim=-1).cpu().tolist()
 
         prob_true = round(max(0.0, min(1.0, probs[0])), 4)
-        return NoulAnswer(noul=prob_true)
+        return self._commit_noul(NoulAnswer(noul=prob_true))
+
+    def _commit_noul(self, ans: NoulAnswer) -> NoulAnswer:
+        if self.noul_decision == "raw":
+            return ans
+        ans.noul = round(_noul_decide(float(ans.noul), self.noul_band_edge, self.noul_band_slope), 4)
+        return ans
 
     def evaluate_score(
         self,
 
@@ -58,11 +58,20 @@ def main():
     help="State longer than the window: middle-truncate with a warning (default) or refuse with HTTP 422 "
          "(env VON_ON_OVERFLOW). Use refuse under no-truncation benchmark rules.",
 )
+@click.option(
+    "--noul-decision",
+    type=click.Choice(["band", "raw"]),
+    default=None,
+    help="Noul P(yes): 'band' (default) commits every answer outside the 0.2..0.8 abstention band, "
+         "'raw' returns the calibrated posterior unchanged (env VON_NOUL_DECISION).",
+)
 def serve(host: str, port: int, backend: str, device: str, reload: bool, max_state_tokens: Optional[int],
-          chains: Optional[str], no_chains: bool, on_overflow: Optional[str]):
+          chains: Optional[str], no_chains: bool, on_overflow: Optional[str], noul_decision: Optional[str]):
+    """Start the Von System One HTTP server."""
     if on_overflow:
         os.environ["VON_ON_OVERFLOW"] = on_overflow
-    """Start the Von System One HTTP server."""
+    if noul_decision:
+        os.environ["VON_NOUL_DECISION"] = noul_decision
     os.environ["VON_BACKEND"] = backend
     if no_chains:
         os.environ["VON_CHAINS_DIR"] = "off"
 
@@ -0,0 +1,48 @@
+"""Noul decision rule: committed P(yes) outside the 0.2..0.8 abstention band."""
+import os
+
+import pytest
+
+from von.backends.option_marker_backend import _noul_decide
+
+
+@pytest.mark.parametrize("p", [0.0, 0.1, 0.3, 0.49, 0.5, 0.51, 0.7, 0.9, 1.0])
+def test_band_never_lands_in_abstention_band(p):
+    out = _noul_decide(p, 0.8, 0.1)
+    assert out <= 0.2 or out >= 0.8
+    assert (out >= 0.5) == (p >= 0.5), "argmax must be preserved"
+
+
+def test_band_is_monotone_and_bounded():
+    ps = [i / 100 for i in range(101)]
+    outs = [_noul_decide(p, 0.8, 0.1) for p in ps]
+    assert all(a <= b for a, b in zip(outs, outs[1:]))
+    assert 0.0 <= min(outs) and max(outs) <= 1.0
+    assert _noul_decide(0.5, 0.8, 0.1) == pytest.approx(0.8)
+    assert _noul_decide(1.0, 0.8, 0.1) == pytest.approx(0.85)
+    assert _noul_decide(0.0, 0.8, 0.1) == pytest.approx(0.15)
+
+
+def test_identity_parameters_are_a_noop():
+    for p in (0.0, 0.25, 0.5, 0.75, 1.0):
+        assert _noul_decide(p, 0.5, 1.0) == pytest.approx(p)
+
+
+def test_backend_applies_band_by_default_and_raw_disables_it(monkeypatch):
+    from von.backends.option_marker_backend import OptionMarkerBackend
+    from von.types import NoulAnswer
+
+    monkeypatch.delenv("VON_NOUL_DECISION", raising=False)
+    b = OptionMarkerBackend.__new__(OptionMarkerBackend)
+    b.noul_decision, b.noul_band_edge, b.noul_band_slope = "band", 0.8, 0.1
+    assert b._commit_noul(NoulAnswer(noul=0.62)).noul == pytest.approx(0.812)
+    b.noul_decision = "raw"
+    assert b._commit_noul(NoulAnswer(noul=0.62)).noul == pytest.approx(0.62)
+
+
+def test_env_validation(monkeypatch):
+    from von.backends.option_marker_backend import OptionMarkerBackend
+
+    monkeypatch.setenv("VON_NOUL_DECISION", "sometimes")
+    with pytest.raises(ValueError, match="VON_NOUL_DECISION"):
+        OptionMarkerBackend(checkpoint_dir=os.path.join("checkpoints", "von-1.2"), device="cpu")