jev-trust 0.1.0__tar.gz

jev_trust-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nautilus Assay (Yiluo Technology)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jev_trust-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: jev-trust
+Version: 0.1.0
+Summary: Trust middleware for Jev decision APIs - log every call, measure calibration in YOUR domain, spend confidence at its verified exchange rate.
+License: MIT
+Project-URL: Homepage, https://github.com/chunxiaoxx/nautilus-compass
+Project-URL: Research, https://github.com/chunxiaoxx/nautilus-compass/discussions/59
+Project-URL: Wall, https://compass.nautilus.social/wall.html
+Keywords: jev,calibration,trust,ai,agents,decision-making,verification,ece,brier
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# jev-trust
+
+**Trust middleware for Jev decision APIs — spend confidence at its verified exchange rate.**
+
+Jev gives you calibrated-looking probabilities. But calibration is a property of
+**(model, domain)** pairs, not models. We measured hosted Jev 1.13 at
+ECE 0.041 on closed deterministic tasks — and **accuracy 50% while stating
+91% confidence** on synthetic email triage ([Assay research #1/#2](https://github.com/chunxiaoxx/nautilus-compass/discussions/59)).
+Same model. Same day. The number you actually care about is the one for *your* domain,
+and nobody has measured it yet — including the vendor.
+
+`jev-trust` wraps the Jev API and measures it in *your* domain while you work:
+
+- **Every call logged** — append-only JSONL: question, answer, stated confidence, effective confidence, usage, timestamp.
+- **Outcomes fed back** — as ground truth arrives, `record_outcome()` builds your domain's calibration record: accuracy, Brier, ECE, and calibration currency **C = 1 − ECE**.
+- **Effective confidence on every answer** — `r.effective_confidence` = what the stated confidence is *worth* here so far (observed accuracy of the matching confidence bin, ≥5 samples; else C-adjusted; else `None` = insufficient evidence).
+- **Overconfidence alerts** — a callback fires when a decision is confident enough to act on but the domain hasn't earned that confidence yet.
+- **Signed evidence** — one call signs the whole log (ed25519). Publish log + sig + pubkey; anyone — including [Nautilus Assay](https://compass.nautilus.social/wall.html) — can independently recompute your numbers.
+
+Zero dependencies. Pure stdlib. Python ≥ 3.8.
+
+## Install
+
+```bash
+pip install jev-trust
+```
+
+## Quickstart
+
+```python
+from jev_trust import TrustedJev
+
+jev = TrustedJev(api_key=API_KEY, domain="email-triage")
+
+# decide() never lets unexamined confidence through:
+r = jev.decide(state, {"q": {"type": "choice", "instructions": "...",
+                             "criteria": {...}}})["q"]
+
+r.decision              # 'alpha'
+r.stated_confidence     # 0.91   <- what Jev claims
+r.effective_confidence  # 0.50   <- what 0.91 is worth in YOUR domain so far
+r.basis                 # 'bin_observed' | 'C_adjusted' | 'insufficient_n'
+r.domain_verdict        # FACE_VALUE | DISCOUNT | DOWNGRADE | UNVERIFIED
+
+# feed ground truth back as it arrives:
+jev.record_outcome("q", truth)
+
+# your domain's running scorecard:
+jev.stats()
+# {'n_outcomes': 42, 'accuracy': 0.52, 'brier': 0.41, 'ece': 0.39,
+#  'C': 0.61, 'verdict': 'DISCOUNT', ...}
+```
+
+## The alert that pays for itself
+
+```python
+def on_overconfidence(r):
+    # fired when stated >= 0.90 but the domain hasn't earned FACE_VALUE
+    log.warning(f"{r.qid}: Jev says {r.stated_confidence}, "
+                f"worth {r.effective_confidence} here — route to human?")
+
+jev = TrustedJev(api_key=API_KEY, domain="fraud-flag",
+                 alert_confidence=0.90, on_overconfidence=on_overconfidence)
+```
+
+## Verdicts (Assay calibration-currency reading levels)
+
+| Verdict | Condition | Reading |
+|---|---|---|
+| `UNVERIFIED` | < 20 outcomes in domain | stated confidence is an unbacked claim |
+| `FACE_VALUE` | C ≥ 0.80 | use stated confidence as-is |
+| `DISCOUNT` | 0.50 ≤ C < 0.80 | multiply trust by C |
+| `DOWNGRADE` | C < 0.50 | route to human review |
+
+The library ships with Assay's published reference rates (informational — your
+verdict is always computed from *your* outcomes):
+
+```python
+jev_trust.ASSAY_REFERENCE_RATES
+# {'closed-deterministic': {'C': 0.959, ...},   # n=240, ECE 0.041
+#  'adversarial-stress':  {'C': 0.988, ...},    # n=200, ECE 0.012
+#  'synthetic-email-choice': {'C': 0.086, ...}} # acc 50% @ conf 91%
+```
+
+## Signed evidence — make your numbers independently checkable
+
+```python
+sig_path = jev.sign_log()          # writes <log>.jsonl.sig
+jev.keys.pub_hex                   # publish this next to the log
+
+# anyone can verify:
+from jev_trust import verify_log
+verify_log("session.jsonl", "session.jsonl.sig", pub_hex)  # -> VALID
+```
+
+Same canonical-JSON + ed25519 scheme as
+[assay-verify](https://pypi.org/project/assay-verify/) — a signed `jev-trust`
+log is directly submittable to Nautilus Assay for independent recomputation
+(the evidence format behind their [Domain Calibration Reports](https://compass.nautilus.social/dcr.html)).
+
+## Why this exists
+
+Nautilus Assay independently verifies AI-agent performance claims. Their two
+public Jev studies found: overall accuracy 92.2% / Brier 0.048 on closed tasks
+(good), but domain calibration collapses on distribution shift — 50% accuracy
+at 91% stated confidence in one synthetic triage domain. Vendor benchmarks
+can't see your domain. `jev-trust` is the always-on instrument that can.
+
+Methodology: ECE = equal-width 10-bin top-label; Brier = mean (1 − p_true)²
+(binary-identical to the standard (p − y)² form). Identical formulas to Assay's
+published verification code.
+
+## License
+
+MIT. © 2026 Nautilus Assay.

jev_trust-0.1.0/README.md

@@ -0,0 +1,115 @@
+# jev-trust
+
+**Trust middleware for Jev decision APIs — spend confidence at its verified exchange rate.**
+
+Jev gives you calibrated-looking probabilities. But calibration is a property of
+**(model, domain)** pairs, not models. We measured hosted Jev 1.13 at
+ECE 0.041 on closed deterministic tasks — and **accuracy 50% while stating
+91% confidence** on synthetic email triage ([Assay research #1/#2](https://github.com/chunxiaoxx/nautilus-compass/discussions/59)).
+Same model. Same day. The number you actually care about is the one for *your* domain,
+and nobody has measured it yet — including the vendor.
+
+`jev-trust` wraps the Jev API and measures it in *your* domain while you work:
+
+- **Every call logged** — append-only JSONL: question, answer, stated confidence, effective confidence, usage, timestamp.
+- **Outcomes fed back** — as ground truth arrives, `record_outcome()` builds your domain's calibration record: accuracy, Brier, ECE, and calibration currency **C = 1 − ECE**.
+- **Effective confidence on every answer** — `r.effective_confidence` = what the stated confidence is *worth* here so far (observed accuracy of the matching confidence bin, ≥5 samples; else C-adjusted; else `None` = insufficient evidence).
+- **Overconfidence alerts** — a callback fires when a decision is confident enough to act on but the domain hasn't earned that confidence yet.
+- **Signed evidence** — one call signs the whole log (ed25519). Publish log + sig + pubkey; anyone — including [Nautilus Assay](https://compass.nautilus.social/wall.html) — can independently recompute your numbers.
+
+Zero dependencies. Pure stdlib. Python ≥ 3.8.
+
+## Install
+
+```bash
+pip install jev-trust
+```
+
+## Quickstart
+
+```python
+from jev_trust import TrustedJev
+
+jev = TrustedJev(api_key=API_KEY, domain="email-triage")
+
+# decide() never lets unexamined confidence through:
+r = jev.decide(state, {"q": {"type": "choice", "instructions": "...",
+                             "criteria": {...}}})["q"]
+
+r.decision              # 'alpha'
+r.stated_confidence     # 0.91   <- what Jev claims
+r.effective_confidence  # 0.50   <- what 0.91 is worth in YOUR domain so far
+r.basis                 # 'bin_observed' | 'C_adjusted' | 'insufficient_n'
+r.domain_verdict        # FACE_VALUE | DISCOUNT | DOWNGRADE | UNVERIFIED
+
+# feed ground truth back as it arrives:
+jev.record_outcome("q", truth)
+
+# your domain's running scorecard:
+jev.stats()
+# {'n_outcomes': 42, 'accuracy': 0.52, 'brier': 0.41, 'ece': 0.39,
+#  'C': 0.61, 'verdict': 'DISCOUNT', ...}
+```
+
+## The alert that pays for itself
+
+```python
+def on_overconfidence(r):
+    # fired when stated >= 0.90 but the domain hasn't earned FACE_VALUE
+    log.warning(f"{r.qid}: Jev says {r.stated_confidence}, "
+                f"worth {r.effective_confidence} here — route to human?")
+
+jev = TrustedJev(api_key=API_KEY, domain="fraud-flag",
+                 alert_confidence=0.90, on_overconfidence=on_overconfidence)
+```
+
+## Verdicts (Assay calibration-currency reading levels)
+
+| Verdict | Condition | Reading |
+|---|---|---|
+| `UNVERIFIED` | < 20 outcomes in domain | stated confidence is an unbacked claim |
+| `FACE_VALUE` | C ≥ 0.80 | use stated confidence as-is |
+| `DISCOUNT` | 0.50 ≤ C < 0.80 | multiply trust by C |
+| `DOWNGRADE` | C < 0.50 | route to human review |
+
+The library ships with Assay's published reference rates (informational — your
+verdict is always computed from *your* outcomes):
+
+```python
+jev_trust.ASSAY_REFERENCE_RATES
+# {'closed-deterministic': {'C': 0.959, ...},   # n=240, ECE 0.041
+#  'adversarial-stress':  {'C': 0.988, ...},    # n=200, ECE 0.012
+#  'synthetic-email-choice': {'C': 0.086, ...}} # acc 50% @ conf 91%
+```
+
+## Signed evidence — make your numbers independently checkable
+
+```python
+sig_path = jev.sign_log()          # writes <log>.jsonl.sig
+jev.keys.pub_hex                   # publish this next to the log
+
+# anyone can verify:
+from jev_trust import verify_log
+verify_log("session.jsonl", "session.jsonl.sig", pub_hex)  # -> VALID
+```
+
+Same canonical-JSON + ed25519 scheme as
+[assay-verify](https://pypi.org/project/assay-verify/) — a signed `jev-trust`
+log is directly submittable to Nautilus Assay for independent recomputation
+(the evidence format behind their [Domain Calibration Reports](https://compass.nautilus.social/dcr.html)).
+
+## Why this exists
+
+Nautilus Assay independently verifies AI-agent performance claims. Their two
+public Jev studies found: overall accuracy 92.2% / Brier 0.048 on closed tasks
+(good), but domain calibration collapses on distribution shift — 50% accuracy
+at 91% stated confidence in one synthetic triage domain. Vendor benchmarks
+can't see your domain. `jev-trust` is the always-on instrument that can.
+
+Methodology: ECE = equal-width 10-bin top-label; Brier = mean (1 − p_true)²
+(binary-identical to the standard (p − y)² form). Identical formulas to Assay's
+published verification code.
+
+## License
+
+MIT. © 2026 Nautilus Assay.

jev_trust-0.1.0/jev_trust/__init__.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+"""jev-trust · trust middleware for Jev decision APIs.
+
+Three lines::
+
+    from jev_trust import TrustedJev
+
+    jev = TrustedJev(api_key=..., domain="email-triage")
+    r = jev.decide(state, {"q": q})["q"]
+    r.stated_confidence, r.effective_confidence, r.domain_verdict
+
+Every call is logged; record outcomes and the session measures how much
+Jev's stated confidence is actually worth in YOUR domain (accuracy, Brier,
+ECE, calibration currency C = 1 - ECE). Logs sign with ed25519 for
+independent recomputation (Assay-compatible).
+"""
+from .calib import (CalibrationState, Prediction, ece_toplabel, brier,
+                    verdict_for, effective_confidence,
+                    FACE_VALUE, DISCOUNT, DOWNGRADE, UNVERIFIED)
+from .client import JevClient, JevAPIError, top_label, correctness
+from .receipt import KeyPair, ReceiptResult, verify_log
+from .trust import TrustedJev, TrustResult, ASSAY_REFERENCE_RATES
+
+__version__ = "0.1.0"
+__all__ = [
+    "TrustedJev", "TrustResult", "ASSAY_REFERENCE_RATES",
+    "CalibrationState", "Prediction", "ece_toplabel", "brier",
+    "verdict_for", "effective_confidence",
+    "FACE_VALUE", "DISCOUNT", "DOWNGRADE", "UNVERIFIED",
+    "JevClient", "JevAPIError", "top_label", "correctness",
+    "KeyPair", "ReceiptResult", "verify_log",
+]

jev_trust-0.1.0/jev_trust/calib.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+"""Runtime calibration tracking — the same math Assay uses (ECE top-label, Brier).
+
+ECE = sum over equal-width confidence bins of (bin share) * |bin accuracy - bin confidence|.
+For binary (noul) questions the top-label confidence is max(p, 1-p); for choice
+questions it is the probability of the chosen option. Identical formulas to
+nautilus-compass verifypack calibration checks (cross-validated against
+sklearn-style references in Assay research #1/#2).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+DEFAULT_BINS = 10
+MIN_BIN_SAMPLES = 5  # below this a bin's observed accuracy is not trustworthy
+
+
+@dataclass(frozen=True)
+class Prediction:
+    """One recorded decision/outcome pair."""
+    qid: str
+    stated_confidence: float  # top-label confidence the model claimed
+    correct: int  # 1 / 0 — was the top-label decision right
+    p_true: float  # probability the model assigned to the TRUE outcome
+
+
+def _top_label_binary(p: float) -> float:
+    """Jev noul answers state P(yes); top-label confidence = max(p, 1-p)."""
+    return max(p, 1.0 - p)
+
+
+def brier(preds: List[Prediction]) -> float:
+    """mean((1 - p_true)^2) — probability mass the model denied the truth.
+    For binary questions identical to the standard (p - y)^2 form."""
+    if not preds:
+        raise ValueError("no predictions")
+    return round(sum((1.0 - pr.p_true) ** 2 for pr in preds) / len(preds), 8)
+
+
+def _bin_of(conf: float, nbins: int) -> int:
+    return min(int(conf * nbins), nbins - 1)
+
+
+def ece_toplabel(preds: List[Prediction], nbins: int = DEFAULT_BINS) -> float:
+    """Equal-width binned top-label ECE."""
+    if not preds:
+        raise ValueError("no predictions")
+    bins: dict = {}
+    for pr in preds:
+        b = _bin_of(pr.stated_confidence, nbins)
+        acc_sum, conf_sum, cnt = bins.get(b, (0.0, 0.0, 0))
+        bins[b] = (acc_sum + pr.correct, conf_sum + pr.stated_confidence, cnt + 1)
+    total = len(preds)
+    ece = 0.0
+    for acc_sum, conf_sum, cnt in bins.values():
+        ece += (cnt / total) * abs(acc_sum / cnt - conf_sum / cnt)
+    return round(ece, 8)
+
+
+@dataclass
+class CalibrationState:
+    """Accumulated calibration evidence for one domain."""
+    preds: List[Prediction] = field(default_factory=list)
+
+    def add(self, pred: Prediction) -> "CalibrationState":
+        self.preds.append(pred)
+        return self
+
+    @property
+    def n(self) -> int:
+        return len(self.preds)
+
+    @property
+    def accuracy(self) -> Optional[float]:
+        if not self.preds:
+            return None
+        return round(sum(p.correct for p in self.preds) / len(self.preds), 4)
+
+    @property
+    def ece(self) -> Optional[float]:
+        if not self.preds:
+            return None
+        return ece_toplabel(self.preds)
+
+    @property
+    def brier(self) -> Optional[float]:
+        if not self.preds:
+            return None
+        return brier(self.preds)
+
+    @property
+    def C(self) -> Optional[float]:
+        """Calibration currency: C = 1 - ECE (Assay definition)."""
+        if not self.preds:
+            return None
+        return round(1.0 - self.ece, 4)
+
+    def bin_accuracy(self, conf: float, nbins: int = DEFAULT_BINS,
+                     min_samples: int = MIN_BIN_SAMPLES) -> Optional[float]:
+        """Observed accuracy among past decisions that stated confidence in the
+        same bin — 'what is this confidence worth in my domain'. None if the bin
+        has too few samples to say anything."""
+        b = _bin_of(conf, nbins)
+        same = [p.correct for p in self.preds if _bin_of(p.stated_confidence, nbins) == b]
+        if len(same) < min_samples:
+            return None
+        return round(sum(same) / len(same), 4)
+
+
+# ── trust verdicts (Assay calibration-currency reading levels) ────────────
+
+FACE_VALUE_C = 0.80
+DISCOUNT_C = 0.50
+
+FACE_VALUE = "FACE_VALUE"      # C >= 0.80: stated confidence may be used at face value
+DISCOUNT = "DISCOUNT"          # 0.50 <= C < 0.80: trust stated confidence times C
+DOWNGRADE = "DOWNGRADE"        # C < 0.50: route to human review
+UNVERIFIED = "UNVERIFIED"      # not enough measured evidence in this domain yet
+
+
+def verdict_for(C: Optional[float], n: int, min_n: int = 20) -> str:
+    """Verdict from measured calibration currency. Needs min_n outcomes before
+    any 'verified' verdict is issued — below that everything is UNVERIFIED
+    (the same discipline Assay applies to its own numbers)."""
+    if C is None or n < min_n:
+        return UNVERIFIED
+    if C >= FACE_VALUE_C:
+        return FACE_VALUE
+    if C >= DISCOUNT_C:
+        return DISCOUNT
+    return DOWNGRADE
+
+
+def effective_confidence(state: CalibrationState, stated: float) -> Tuple[Optional[float], str]:
+    """How much a stated confidence is worth in this domain, given evidence.
+
+    Priority: (1) observed accuracy of the matching confidence bin (>=5 samples);
+    (2) binless fallback: stated confidence adjusted by measured C; (3) None —
+    insufficient evidence, caller must fall back to its own policy."""
+    if state.n == 0:
+        return None, UNVERIFIED
+    bin_acc = state.bin_accuracy(stated)
+    if bin_acc is not None:
+        return bin_acc, "bin_observed"
+    if state.n >= 20:
+        return round(0.5 + state.C * (stated - 0.5), 4), "C_adjusted"
+    return None, "insufficient_n"

jev_trust-0.1.0/jev_trust/client.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""Minimal Jev API client (TypeSafe System One endpoint), pure stdlib.
+
+The transport is injectable so tests run offline and callers can plug in
+their own HTTP stack / mocks.
+"""
+from __future__ import annotations
+
+import json
+import time
+import urllib.request
+from typing import Callable, Dict, Optional
+
+DEFAULT_ENDPOINT = "https://api.typesafe.ai/v1/systemone"
+DEFAULT_MODEL = "jev-latest"
+DEFAULT_TIMEOUT = 60
+
+Transport = Callable[[str, bytes, Dict[str, str]], dict]
+"""transport(url, body_bytes, headers) -> parsed json response dict"""
+
+
+def _urllib_transport(url: str, body: bytes, headers: Dict[str, str]) -> dict:
+    req = urllib.request.Request(url, data=body, method="POST", headers=headers)
+    with urllib.request.urlopen(req, timeout=DEFAULT_TIMEOUT) as r:
+        return json.loads(r.read())
+
+
+class JevClient:
+    def __init__(self, api_key: str, endpoint: str = DEFAULT_ENDPOINT,
+                 model: str = DEFAULT_MODEL, transport: Optional[Transport] = None):
+        self.api_key = api_key
+        self.endpoint = endpoint
+        self.model = model
+        self._transport = transport or _urllib_transport
+        self.calls = 0
+        self.errors = 0
+
+    def decide(self, state: dict, questions: dict, retries: int = 2,
+               retry_delay: float = 1.0) -> dict:
+        """Call Jev once. questions = {qid: {type: noul|choice|score, ...}}.
+        Returns the raw response dict {answers: {...}, usage: {...}}.
+        Transient errors are retried; content is never retried (no fishing
+        for better answers — Assay discipline)."""
+        body = json.dumps({"model": self.model, "state": state,
+                           "questions": questions}).encode()
+        headers = {"Authorization": "Bearer " + self.api_key,
+                   "Content-Type": "application/json"}
+        last_err = None
+        for attempt in range(retries + 1):
+            self.calls += 1
+            try:
+                return self._transport(self.endpoint, body, headers)
+            except Exception as e:  # network/5xx class only reaches here
+                self.errors += 1
+                last_err = e
+                if attempt < retries:
+                    time.sleep(retry_delay * (attempt + 1))
+        raise JevAPIError(f"jev api failed after {retries + 1} attempts: {last_err}")
+
+
+class JevAPIError(RuntimeError):
+    pass
+
+
+# ── answer normalization ──────────────────────────────────────────────────
+
+def top_label(answer: dict) -> dict:
+    """Normalize a Jev answer into {decision, stated_confidence, probabilities}.
+
+    - noul:   {noul: 0.93, type: noul}                -> decision yes/no
+    - choice: {choice: 'alpha', probabilities: {...}} -> decision 'alpha'
+    - score:  {score: 0.8, type: score}               -> value 0.8, confidence 1.0
+    """
+    t = answer.get("type")
+    if t == "noul":
+        p = float(answer["noul"])
+        decision = "yes" if p >= 0.5 else "no"
+        return {"decision": decision, "stated_confidence": max(p, 1.0 - p),
+                "probabilities": {"yes": p, "no": 1.0 - p}}
+    if t == "choice":
+        probs = dict(answer.get("probabilities") or {})
+        decision = answer.get("choice")
+        stated = answer.get("confidence")
+        if stated is None:
+            stated = max(probs.values()) if probs else 1.0
+        return {"decision": decision, "stated_confidence": float(stated),
+                "probabilities": probs}
+    if t == "score":
+        return {"decision": float(answer["score"]), "stated_confidence": 1.0,
+                "probabilities": None}
+    raise ValueError(f"unknown answer type: {t!r}")
+
+
+def correctness(top: dict, truth) -> int:
+    """Was the top-label decision correct, given ground truth?
+    noul: truth in {0,1} vs decision yes/no; choice: string equality.
+    score answers carry no notion of correctness — raise rather than guess."""
+    decision = top["decision"]
+    if isinstance(decision, float):
+        raise ValueError("score answers have no top-label correctness")
+    if decision in ("yes", "no"):
+        yes = {1: "yes", 0: "no", True: "yes", False: "no"}.get(truth)
+        if yes is None:
+            raise ValueError(f"bad truth for noul answer: {truth!r}")
+        return 1 if decision == yes else 0
+    return 1 if str(decision) == str(truth) else 0

jev_trust-0.1.0/jev_trust/ed25519.py

@@ -0,0 +1,129 @@
+# -*- coding: utf-8 -*-
+"""ed25519 (RFC 8032) — vendored reference implementation.
+
+Same source as assay-verify (sdks/assay-verify) and nautilus-compass
+tools/verifypack; the three implementations are cross-validated (VALID
+both ways, 2026-09-19). Pure python, zero dependencies.
+"""
+from __future__ import annotations
+
+import hashlib
+import secrets
+
+_p = 2**255 - 19
+_q = 2**252 + 27742317777372353535851937790883648493
+
+
+def _inv(x: int) -> int:
+    return pow(x, _p - 2, _p)
+
+
+_d = -121665 * _inv(121666) % _p
+_I = pow(2, (_p - 1) // 4, _p)
+
+
+def _xrecover(y: int) -> int:
+    xx = (y * y - 1) * _inv(_d * y * y + 1)
+    x = pow(xx, (_p + 3) // 8, _p)
+    if (x * x - xx) % _p != 0:
+        x = x * _I % _p
+    if x % 2 != 0:
+        x = _p - x
+    return x
+
+
+_By = 4 * _inv(5) % _p
+_Bx = _xrecover(_By)
+_B = (_Bx % _p, _By % _p, 1, _Bx * _By % _p)
+
+
+def _edwards_add(P, Q):
+    x1, y1, z1, t1 = P
+    x2, y2, z2, t2 = Q
+    a = (y1 - x1) * (y2 - x2) % _p
+    b = (y1 + x1) * (y2 + x2) % _p
+    c = t1 * 2 * _d * t2 % _p
+    dd = z1 * 2 * z2 % _p
+    e, f, g, h = b - a, dd - c, dd + c, b + a
+    return (e * f % _p, g * h % _p, f * g % _p, e * h % _p)
+
+
+def _scalarmult(P, e):
+    if e == 0:
+        return (0, 1, 1, 0)
+    Q = _scalarmult(P, e // 2)
+    Q = _edwards_add(Q, Q)
+    if e & 1:
+        Q = _edwards_add(Q, P)
+    return Q
+
+
+def _point_decompress(s: bytes):
+    if len(s) != 32:
+        raise ValueError("bad point")
+    y = int.from_bytes(s, "little")
+    sign = y >> 255
+    y &= (1 << 255) - 1
+    x = _xrecover(y)
+    if x & 1 != sign:
+        x = _p - x
+    P = (x, y, 1, x * y % _p)
+    if not (0 <= x < _p and 0 <= y < _p):
+        raise ValueError("out of range")
+    return P
+
+
+def _sha512(m: bytes) -> bytes:
+    return hashlib.sha512(m).digest()
+
+
+def _sha512_modq(m: bytes) -> int:
+    return int.from_bytes(_sha512(m), "little") % _q
+
+
+def _encode_point(P) -> bytes:
+    x, y, z, _ = P
+    zinv = _inv(z)
+    x = x * zinv % _p
+    y = y * zinv % _p
+    return (y | ((x & 1) << 255)).to_bytes(32, "little")
+
+
+def sign(msg: bytes, seed: bytes) -> bytes:
+    h = _sha512(seed)
+    a = int.from_bytes(h[:32], "little")
+    a &= (1 << 254) - 8
+    a |= 1 << 254
+    pub = _encode_point(_scalarmult(_B, a))
+    prefix = h[32:]
+    r = _sha512_modq(prefix + msg)
+    Rs = _encode_point(_scalarmult(_B, r))
+    s = (r + _sha512_modq(Rs + pub + msg) * a) % _q
+    return Rs + s.to_bytes(32, "little")
+
+
+def verify(public: bytes, msg: bytes, signature: bytes) -> bool:
+    if len(public) != 32 or len(signature) != 64:
+        return False
+    try:
+        A = _point_decompress(public)
+        R = _point_decompress(signature[:32])
+    except ValueError:
+        return False
+    S = int.from_bytes(signature[32:], "little")
+    h = _sha512_modq(signature[:32] + public + msg)
+    sB = _scalarmult(_B, S)
+    hA = _scalarmult(A, h)
+    RhA = _edwards_add(R, hA)
+    return (sB[1] * RhA[2] - RhA[1] * sB[2]) % _p == 0 \
+        and (sB[0] * RhA[2] - RhA[0] * sB[2]) % _p == 0
+
+
+def keypair() -> tuple:
+    seed = secrets.token_bytes(32)
+    h = _sha512(seed)
+    a = int.from_bytes(h[:32], "little")
+    a &= (1 << 254) - 8
+    a |= 1 << 254
+    pub = _encode_point(_scalarmult(_B, a))
+    return seed, pub