Release Armiger Ultra v3.10.0 (v3.0-gold-r13.10, DHT seq=13 / seq=3013)

README.md

@@ -22,13 +22,13 @@ tags:
   - rats-search
 ---
 
-# Armiger Ultra `v3.8.0`
+# Armiger Ultra `v3.10.0`
 
-**Release:** [`v3.8.0`](https://github.com/spencernorton/armiger/releases/tag/v3.8.0) · **Weights:** `33.3 MB` FP32 ONNX + `17.6 MB` INT8 ONNX · **Parameters:** `8.05M` · **License:** Apache-2.0
+**Release:** [`v3.10.0`](https://github.com/spencernorton/armiger/releases/tag/v3.10.0) · **Weights:** `33.3 MB` FP32 ONNX + `17.6 MB` INT8 ONNX · **Parameters:** `8.05M` · **License:** Apache-2.0
 
 **Armiger Ultra** is an 8.05M-parameter multi-head byte-level RoPE Transformer (`0.21 ms/item` batched GPU) and 6-plugin pipeline for BitTorrent and DHT metadata classification, canonical title/year extraction, audio/subtitle verification, malware filtering, and swarm liveliness scoring.
 
-![Armiger Ultra v3.8.0 Overview](assets/armiger_overview.png)
+![Armiger Ultra v3.10.0 Overview](assets/armiger_overview.png)
 
 ## Quickstart
 
@@ -47,7 +47,7 @@ Armiger package and verifies its declared dependency checksums.
 
 ### Pre-Built Docker Container & Compose Stacks (`v3.4.1`)
 
-Library and container 3.4.1 fix connector startup permissions and use the v3.8.0 model bundle.
+Library and container 3.4.1 fix connector startup permissions and use the v3.10.0 model bundle.
 
 Run the pre-built `armiger-ultra`:
 

armiger.int8.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7ee3dfdaae4283faecabf06bc7d7644d1747d959264506b07065a3035fe6ffd0
-size 17606389
+oid sha256:c39bad25f5e31289d575243473589e023c63327b5d846e26aaeebf9aee7b054c
+size 17606362

armiger_ultra.fp32.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3125e70b22303f1a548e7b890d2b1c078858eed1b987cc9d63c52188fbc630c0
+oid sha256:70286459da47287eb5d984cd67251e0f80f511ceee0ad6ad34c7c2334c9223ec
 size 33260312

armiger_ultra_pipeline.py

@@ -258,7 +258,12 @@ _AUDIOBOOK_FILE_TREE_RE = re.compile(
 def _file_tree_structural_override(row: Mapping[str, Any]) -> Tuple[Optional[str], str]:
     """Check physical file-tree extensions (.m4b/.afpk audiobooks, .cbz/.cbr comics, game engine trees, multi-episode packs) before title lookup."""
     raw_name = str(row.get("name") or row.get("title") or "")
-    files = row.get("files") or []
+    files = list(row.get("files") or [])
+    if not files:
+        ext_hint = str(row.get("extension") or row.get("ext") or "").strip().lstrip(".").lower()
+        synth = f"{raw_name}.{ext_hint}" if ext_hint and not raw_name.lower().endswith(f".{ext_hint}") else raw_name
+        if synth:
+            files = [synth]
     ep_files = 0
     has_afpk = False
     for f in files:
@@ -1409,7 +1414,7 @@ class ArmigerUltraPipeline:
             except ImportError:
                 from oci_sqlite_catalog import build_torrent_bundle
             bobj = build_torrent_bundle(
-                bundle_name=f"armiger-weights-{self.variant}-v3.8.0",
+                bundle_name=f"armiger-weights-{self.variant}-v3.10.0",
                 files_map=files_map,
                 pubkey_32=b"\x00" * 32,
                 salt=f"armiger:weights:{self.variant}".encode("utf-8"),
@@ -2455,7 +2460,7 @@ class ArmigerUltraPipeline:
                 verified_files_map[str(fname)] = fbytes
 
             recomputed = build_torrent_bundle(
-                bundle_name=f"armiger-weights-{self.variant}-v3.8.0",
+                bundle_name=f"armiger-weights-{self.variant}-v3.10.0",
                 files_map=verified_files_map,
                 pubkey_32=bytes.fromhex(eff_pubkey),
                 salt=eff_salt,
@@ -2758,7 +2763,7 @@ class ArmigerUltraPipeline:
                     }
 
         recomputed_bundle = build_torrent_bundle(
-            bundle_name=f"armiger-weights-{self.variant}-v3.8.0",
+            bundle_name=f"armiger-weights-{self.variant}-v3.10.0",
             files_map=files_map,
             pubkey_32=bytes.fromhex(eff_pubkey),
             salt=eff_salt,

calibration.json

@@ -1,5 +1,5 @@
 {
-  "calibrated_onnx_fp32_sha256": "3125e70b22303f1a548e7b890d2b1c078858eed1b987cc9d63c52188fbc630c0",
+  "calibrated_onnx_fp32_sha256": "70286459da47287eb5d984cd67251e0f80f511ceee0ad6ad34c7c2334c9223ec",
   "calibration_version": "v3.0-gold-r13_6-val-only",
   "feature_stats_dim": 41,
   "fitted_snapshot_id": "snap_r13_20261024T140340Z_064c8e6ccb1f",

calibration_and_dht.py

@@ -27,7 +27,10 @@ except ImportError:  # pragma: no cover
     import sre_parse as _sre_parse  # type: ignore[no-redef]
     import sre_constants as _sre_constants  # type: ignore[no-redef]
 
-from pq_xmss_merkle import QuorumSignatureCache, XMSSSignature, XMSSStatefulVerifier
+try:
+    from armiger.pq_xmss_merkle import QuorumSignatureCache, XMSSSignature, XMSSStatefulVerifier
+except ImportError:
+    from pq_xmss_merkle import QuorumSignatureCache, XMSSSignature, XMSSStatefulVerifier  # type: ignore[no-redef]
 
 
 MAX_CUSTOM_REGEX_PATTERN_LEN = 512
@@ -642,6 +645,157 @@ def validate_plugin_overrides_schema(raw_overrides: Any) -> dict[str, dict[str,
     return validated
 
 
+# --- Horvitz-Thompson inverse-stratum-weighted temperature scaling & split-conformal Mondrian quantiles ---
+
+def horvitz_thompson_stratum_weights(classes: list[Any], strata: list[Any]) -> list[float]:
+    """Return design weights `w_i = 1 / n_{c,k}` for row `i` in class `c` and stratum `k`.
+
+    Every `(class, stratum)` cell then carries total mass 1, so a cell of 332 identical
+    100%-confident LibriVox clones counts exactly as much as a cell of 38 course rows.
+    """
+    if len(classes) != len(strata):
+        raise ValueError("classes and strata must have the same length")
+    counts: dict[tuple[Any, Any], int] = {}
+    for c, k in zip(classes, strata):
+        counts[(c, k)] = counts.get((c, k), 0) + 1
+    return [1.0 / counts[(c, k)] for c, k in zip(classes, strata)]
+
+
+def weighted_nll(probs: list[list[float]], y: list[int], weights: list[float]) -> float:
+    """Weighted mean negative log-likelihood of the true class."""
+    wsum = sum(weights)
+    if wsum <= 0.0:
+        raise ValueError("weights must have positive total mass")
+    return sum(-w * math.log(max(p[t], 1e-12)) for p, t, w in zip(probs, y, weights)) / wsum
+
+
+def fit_weighted_temperature(
+    logits: list[list[float]],
+    y: list[int],
+    weights: list[float] | None = None,
+    *,
+    t_min: float = 0.5,
+    t_max: float = 2.5,
+    grid_steps: int = 81,
+    guard: bool = True,
+) -> dict[str, Any]:
+    """Grid-search the temperature minimising (weighted) NLL; with `guard=True` ship `T=1.0`
+    unless the best candidate beats it (same guard as the R5clean/R6 trainers).
+    """
+    n = len(logits)
+    if n == 0 or n != len(y):
+        raise ValueError("logits and y must be non-empty and aligned")
+    w = list(weights) if weights is not None else [1.0] * n
+    nll_at_1 = weighted_nll([_softmax(z) for z in logits], y, w)
+    best_t, best_nll = 1.0, nll_at_1
+    for i in range(grid_steps):
+        t_cand = round(t_min + (t_max - t_min) * i / max(1, grid_steps - 1), 4)
+        nll_c = weighted_nll([_softmax(z, temperature=t_cand) for z in logits], y, w)
+        if nll_c < best_nll - 1e-6:
+            best_nll, best_t = nll_c, t_cand
+    shipped = best_t if (not guard or best_nll < nll_at_1 - 1e-6) else 1.0
+    return {
+        "temperature": shipped,
+        "best_T_unclamped": best_t,
+        "weighted_nll_at_T1": round(nll_at_1, 6),
+        "weighted_nll_at_best_T": round(best_nll, 6),
+        "n": n,
+        "weighting": "uniform" if weights is None else "horvitz_thompson_inverse_stratum",
+    }
+
+
+def weighted_conformal_quantile(scores: list[float], weights: list[float] | None, alpha: float) -> float:
+    """Weighted split-conformal `(1 - alpha)` quantile (Tibshirani et al. 2019).
+
+    The calibration scores get normalised weights `w_i / (sum_j w_j + w_test)` plus a point mass
+    at `+inf` for the test row (`w_test = max(w)`, conservative). With uniform weights this is
+    exactly `s_(ceil((n + 1)(1 - alpha)))`, the unweighted rule the trainers already use.
+    Returns `1.0` (never fires) if the `+inf` mass is needed to reach `1 - alpha`.
+    """
+    n = len(scores)
+    if n == 0:
+        raise ValueError("scores cannot be empty")
+    if not (0.0 < alpha < 1.0):
+        raise ValueError("alpha must be in (0, 1)")
+    w = list(weights) if weights is not None else [1.0] * n
+    if len(w) != n or any(x <= 0.0 for x in w):
+        raise ValueError("weights must be positive and aligned with scores")
+    w_test = max(w)
+    total = sum(w) + w_test
+    order = sorted(range(n), key=lambda i: scores[i])
+    cum = 0.0
+    for i in order:
+        cum += w[i] / total
+        if cum >= (1.0 - alpha) - 1e-12:
+            return float(scores[i])
+    return 1.0
+
+
+def fit_stratum_weighted_mondrian_gate(
+    p_positive: list[float],
+    y: list[int],
+    strata: list[Any],
+    alpha: float,
+    *,
+    shrinkage_m: float = 0.0,
+) -> dict[str, Any]:
+    """Fit the `scope_excluded`-style one-sided gate `p_positive >= tau` with FPR control on negatives.
+
+    `tau_global` is the Horvitz-Thompson-weighted conformal quantile over all negatives (`y == 0`);
+    `per_stratum[k]` is the Mondrian (stratum-conditional) quantile over the negatives of stratum `k`.
+    Strata with no negatives (every row positive) inherit `tau_global` and are listed in
+    `strata_without_negatives` — no FPR constraint exists there, so nothing lower can be certified.
+    """
+    if not (len(p_positive) == len(y) == len(strata)) or not p_positive:
+        raise ValueError("p_positive, y and strata must be non-empty and aligned")
+    w = horvitz_thompson_stratum_weights(y, strata)
+    neg_idx = [i for i, t in enumerate(y) if t == 0]
+    if not neg_idx:
+        raise ValueError("no negatives (y == 0) to fit an FPR-controlled gate on")
+    tau_global = weighted_conformal_quantile([p_positive[i] for i in neg_idx], [w[i] for i in neg_idx], alpha)
+    per_stratum: dict[str, float] = {}
+    audit: dict[str, dict[str, Any]] = {}
+    no_neg: list[str] = []
+    for k in sorted({str(s) for s in strata}):
+        idx = [i for i, s in enumerate(strata) if str(s) == k]
+        k_neg = [i for i in idx if y[i] == 0]
+        k_pos = [i for i in idx if y[i] == 1]
+        if k_neg:
+            raw_tau_k = weighted_conformal_quantile([p_positive[i] for i in k_neg], None, alpha)
+            if shrinkage_m > 0.0:
+                lam = len(k_neg) / (len(k_neg) + float(shrinkage_m))
+                tau_k = lam * raw_tau_k + (1.0 - lam) * tau_global
+            else:
+                tau_k = raw_tau_k
+        else:
+            tau_k = tau_global
+            no_neg.append(k)
+        per_stratum[k] = round(tau_k, 6)
+        audit[k] = {
+            "n_neg": len(k_neg),
+            "n_pos": len(k_pos),
+            "tau": round(tau_k, 6),
+            "val_fpr_at_tau": round(sum(1 for i in k_neg if p_positive[i] >= tau_k) / len(k_neg), 6) if k_neg else None,
+            "val_recall_at_tau": round(sum(1 for i in k_pos if p_positive[i] >= tau_k) / len(k_pos), 6) if k_pos else None,
+        }
+    n_neg = len(neg_idx)
+    return {
+        "alpha": alpha,
+        "tau_global": round(tau_global, 6),
+        "per_stratum": per_stratum,
+        "strata_without_negatives": no_neg,
+        "n_neg": n_neg,
+        "n_pos": len(y) - n_neg,
+        "val_fpr_at_tau_global": round(sum(1 for i in neg_idx if p_positive[i] >= tau_global) / n_neg, 6),
+        "val_recall_at_tau_global": round(
+            sum(1 for i, t in enumerate(y) if t == 1 and p_positive[i] >= tau_global) / max(1, len(y) - n_neg), 6
+        ),
+        "stratum_audit": audit,
+        "method": "Horvitz-Thompson inverse-stratum-weighted (w_i = 1/n_{c,k}) split-conformal quantile on val negatives; "
+                  "Mondrian per-stratum quantiles; +inf test-point mass (Tibshirani et al. 2019)",
+    }
+
+
 class ArmigerCalibrator:
     """Applies `calibration.json` temperature scaling, Menon prior adjustments, Mondrian gates,
     and schema-validated data-driven plugin overrides (`Gap S3-01`).
@@ -710,7 +864,9 @@ class ArmigerCalibrator:
                 for k_m, gk in (("adult", "adult"), ("junk", "junk"), ("owner_scope", "owner_scope")):
                     v_m = m_Legacy.get(k_m)
                     if isinstance(v_m, dict):
-                        t_v = v_m.get("threshold", v_m.get("threshold_G250", v_m.get("threshold_H350", self.DEFAULT_MONDRIAN[gk])))
+                        # accept `threshold`, `threshold_G250`, `threshold_r5clean`, ... (trainers suffix the key per run)
+                        t_keys = ["threshold"] + sorted(k for k in v_m if str(k).startswith("threshold_"))
+                        t_v = next((v_m[k] for k in t_keys if k in v_m and isinstance(v_m[k], (int, float))), self.DEFAULT_MONDRIAN[gk])
                         raw_m[gk] = float(t_v)
                     elif isinstance(v_m, (int, float)):
                         raw_m[gk] = float(v_m)
@@ -730,6 +886,29 @@ class ArmigerCalibrator:
             "owner_scope": scope_t,
         }
 
+        # Mondrian per-stratum gate thresholds (written by recalibrate_mondrian_stratum_weighted.py):
+        # {"owner_scope": {"stratum_key": "category", "strata": {"movie": 0.21, ...}}}
+        self.mondrian_strata: dict[str, dict[str, float]] = {}
+        self.mondrian_stratum_key: dict[str, str] = {}
+        raw_strat = active_block.get("mondrian_stratified_thresholds")
+        if raw_strat is None:
+            raw_strat = raw_cfg.get("mondrian_stratified_thresholds")
+        if isinstance(raw_strat, dict):
+            for gate, block in raw_strat.items():
+                if gate not in ("adult", "junk", "owner_scope", "scope") or not isinstance(block, dict):
+                    raise ValueError(f"invalid mondrian_stratified_thresholds block for {gate!r}")
+                strata = block.get("strata")
+                if not isinstance(strata, dict):
+                    raise ValueError(f"mondrian_stratified_thresholds[{gate!r}].strata must be an object")
+                clean: dict[str, float] = {}
+                for k, v in strata.items():
+                    if isinstance(v, bool) or not isinstance(v, (int, float)) or not math.isfinite(float(v)) or not (0.0 < float(v) < 1.0):
+                        raise ValueError(f"invalid stratified mondrian threshold {gate}.{k}={v!r}")
+                    clean[str(k)] = float(v)
+                g_key = "owner_scope" if gate == "scope" else gate
+                self.mondrian_strata[g_key] = clean
+                self.mondrian_stratum_key[g_key] = str(block.get("stratum_key", "category"))
+
         raw_overrides = (
             active_block.get("plugin_overrides")
             if "plugin_overrides" in active_block
@@ -776,11 +955,24 @@ class ArmigerCalibrator:
                 out[head_name] = rounded
         return out
 
+    def gate_threshold(self, gate: str, stratum: str | None = None) -> float:
+        """Threshold for `gate` (`adult` / `junk` / `owner_scope`): the Mondrian per-stratum value when
+        `stratum` (e.g. the predicted category) is known and fitted, else the global value.
+        """
+        g_key = "owner_scope" if gate == "scope" else gate
+        if stratum is not None:
+            per = self.mondrian_strata.get(g_key, {})
+            if str(stratum) in per:
+                return float(per[str(stratum)])
+        return float(self.mondrian[g_key])
+
     def evaluate_safety_gates(
         self,
         p_adult: float,
         p_junk: float,
         p_excluded_scope: float,
+        *,
+        stratum: str | None = None,
     ) -> dict[str, bool]:
         def _flag(val: float, thresh: float) -> bool:
             if isinstance(val, bool) or not isinstance(val, (int, float)) or not math.isfinite(val) or val < 0.0 or val > 1.0:
@@ -788,9 +980,9 @@ class ArmigerCalibrator:
             return bool(val >= thresh)
 
         return {
-            "adult_flagged": _flag(p_adult, float(self.mondrian["adult"])),
-            "junk_flagged": _flag(p_junk, float(self.mondrian["junk"])),
-            "scope_excluded": _flag(p_excluded_scope, float(self.mondrian["owner_scope"])),
+            "adult_flagged": _flag(p_adult, self.gate_threshold("adult", stratum)),
+            "junk_flagged": _flag(p_junk, self.gate_threshold("junk", stratum)),
+            "scope_excluded": _flag(p_excluded_scope, self.gate_threshold("owner_scope", stratum)),
         }
 
 
@@ -844,6 +1036,8 @@ class ArmigerDHTUpdater:
             raise ValueError(f"Unsupported DHT update mode: {mode}")
         if not isinstance(require_pq, bool):
             raise TypeError(f"require_pq must be bool, got {type(require_pq).__name__}")
+        if not require_pq:
+            raise ValueError("require_pq=False is forbidden; post-quantum verification is mandatory")
         self.require_pq = require_pq
         self._min_quorum_is_bool = isinstance(min_quorum, bool)
         self._seq_is_bool = isinstance(current_seq, bool)
@@ -878,7 +1072,10 @@ class ArmigerDHTUpdater:
     @staticmethod
     @functools.lru_cache(maxsize=512)
     def _verify_wots_cached(pq_pub_bytes: bytes, payload: bytes, pq_sig_bytes: bytes) -> bool:
-        from csam_guard import WOTSPlusSHAKE256
+        try:
+            from armiger.csam_guard import WOTSPlusSHAKE256
+        except ImportError:
+            from csam_guard import WOTSPlusSHAKE256
         return bool(WOTSPlusSHAKE256.verify(pq_pub_bytes, payload, pq_sig_bytes))
 
     def verify_bundle(
@@ -906,10 +1103,9 @@ class ArmigerDHTUpdater:
             return False, f"stale_or_replayed_seq:{manifest.seq}<={self.current_seq}"
         if manifest.seq > (2**63 - 1) or manifest.seq > self.current_seq + 1024:
             return False, f"seq_jump_exceeds_max_window:{manifest.seq}"
-        if self._xmss_verifier is None:
-            now_ts = int(time.time())
-            if (manifest.timestamp - now_ts) > 300 or (now_ts - manifest.timestamp) > 14 * 86400:
-                return False, f"manifest_timestamp_out_of_bounds:{manifest.timestamp}"
+        now_ts = int(time.time())
+        if (manifest.timestamp - now_ts) > 300 or (now_ts - manifest.timestamp) > 14 * 86400:
+            return False, f"manifest_timestamp_out_of_bounds:{manifest.timestamp}"
         if self.min_quorum <= 0 or manifest.quorum_attestations < self.min_quorum:
             return False, f"insufficient_quorum:{manifest.quorum_attestations}<{self.min_quorum}"
         if (
@@ -956,6 +1152,7 @@ class ArmigerDHTUpdater:
                 xmss_ok, xmss_reason = self._xmss_verifier.verify_and_advance(
                     message=payload,
                     xmss_sig=xmss_sig_obj,
+                    advance=(commit_seq is None or bool(commit_seq)),
                 )
             except (ValueError, TypeError, KeyError) as exc:
                 return False, f"xmss_signature_parse_error:{exc}"
@@ -985,14 +1182,25 @@ class ArmigerDHTUpdater:
         if not pq_ok:
             return False, "pq_wots_signature_invalid"
 
-        if bool(commit_seq):
+        if commit_seq is None or bool(commit_seq):
             self.commit_bundle(manifest)
         return True, "verified"
 
     def commit_bundle(self, manifest: SignedDHTManifest) -> int:
-        """Advance `self.current_seq` after a verified bundle has been staged and accepted."""
+        """Advance both XMSS verifier state and `self.current_seq` after a verified bundle has been staged and accepted."""
         if isinstance(manifest.seq, bool) or not isinstance(manifest.seq, int) or manifest.seq <= self.current_seq:
             raise ValueError(f"invalid_or_non_monotonic_commit_seq:{manifest.seq}<={self.current_seq}")
+        if self._xmss_verifier is not None and manifest.xmss_signature_hex:
+            xmss_sig_bytes = bytes.fromhex(manifest.xmss_signature_hex)
+            xmss_sig_obj = XMSSSignature.from_bytes(xmss_sig_bytes)
+            if self._xmss_verifier.current_seq < int(manifest.seq):
+                xmss_ok, xmss_reason = self._xmss_verifier.verify_and_advance(
+                    message=manifest.canonical_payload(),
+                    xmss_sig=xmss_sig_obj,
+                    advance=True,
+                )
+                if not xmss_ok:
+                    raise ValueError(f"xmss_commit_verification_failed:{xmss_reason}")
         self.current_seq = int(manifest.seq)
         return self.current_seq
 
@@ -1004,25 +1212,26 @@ class ArmigerDHTUpdater:
         canary_fn: Any | None = None,
         rollback_fn: Any | None = None,
     ) -> tuple[bool, str]:
-        """Verify bundle, run `apply_fn` and optional `canary_fn`, and commit `current_seq` only on success."""
+        """Verify bundle without advancing state, run `apply_fn` and optional `canary_fn`, and commit only on success."""
+        if not callable(apply_fn):
+            return False, "apply_fn_required"
+        if not callable(rollback_fn):
+            return False, "rollback_fn_required_for_safe_apply"
         ok, reason = self.verify_bundle(manifest, bundle_bytes, commit_seq=False)
         if not ok:
             return False, reason
         try:
             apply_res = apply_fn(bundle_bytes)
             if apply_res is False:
-                if rollback_fn is not None:
-                    rollback_fn()
+                rollback_fn()
                 return False, "bundle_application_rejected"
             if canary_fn is not None:
                 canary_ok = canary_fn()
                 if not canary_ok:
-                    if rollback_fn is not None:
-                        rollback_fn()
+                    rollback_fn()
                     return False, "canary_regression_rejected"
         except Exception as exc:
-            if rollback_fn is not None:
-                rollback_fn()
+            rollback_fn()
             return False, f"bundle_application_failed:{exc}"
         self.commit_bundle(manifest)
         return True, "verified_applied_and_committed"

config.json

@@ -1,18 +1,18 @@
 {
   "model_name": "armiger-ultra",
-  "version": "3.8.0",
+  "version": "3.10.0",
   "bundle_type": "unified_armiger_plus_ultra_plus_swarm",
   "architecture": "armiger-v2-byte-rope-transformer-8head + residual-swarm-health-adapter",
   "artifacts": {
     "armiger_cpu_int8_onnx": {
       "file": "armiger.int8.onnx",
-      "size_bytes": 17606389,
-      "sha256": "7ee3dfdaae4283faecabf06bc7d7644d1747d959264506b07065a3035fe6ffd0"
+      "size_bytes": 17606362,
+      "sha256": "c39bad25f5e31289d575243473589e023c63327b5d846e26aaeebf9aee7b054c"
     },
     "armiger_ultra_fp32_onnx": {
       "file": "armiger_ultra.fp32.onnx",
       "size_bytes": 33260312,
-      "sha256": "3125e70b22303f1a548e7b890d2b1c078858eed1b987cc9d63c52188fbc630c0"
+      "sha256": "70286459da47287eb5d984cd67251e0f80f511ceee0ad6ad34c7c2334c9223ec"
     },
     "armiger_ultra_pytorch": {
       "file": "armiger_ultra.pt",
@@ -139,7 +139,7 @@
         "test_armiger_dht_rsi.py"
       ],
       "sha256": {
-        "calibration.json": "ac2fe3b3de8cda9d3e7bca3b334157ac0d90e052e2ff03c3787900b991b13b34",
+        "calibration.json": "92aa6aac07a9868f7a54fc0089eec6b06aa86c759723dd0731e0afd13e617cdd",
         "calibration_and_dht.py": "11be587b60202185abbcf507b935464fed5be5d7c0b28adc38fe5213ca088db5",
         "armiger_dht_rsi.py": "3b709c506e0826fded14d3180516982f91b003f4ad3381a9b13e3909900e11e4",
         "test_armiger_dht_rsi.py": "f284d290cc2a847f152e51ff40112556caf6c256ee2629aa9f31afbefa73d2df"
@@ -176,7 +176,7 @@
       "csam_safety"
     ],
     "sha256": {
-      "armiger_ultra_pipeline.py": "7d6c9588a0ac047b68bd7a296160b77f37f17ffd34049c25ab7d8e75529399bc",
+      "armiger_ultra_pipeline.py": "018de352f0984ad2a7eeacbdd31a8188e11bd2d3c349ccc1740cfd1a92cb3916",
       "test_armiger_ultra_pipeline.py": "b309d0edf87a189f41e95c18511fd26b0d748f981d93f1a0782cd8163015e18d"
     }
   },

zero_cue_plugin.py

@@ -78,6 +78,8 @@ _CONSOLE_TITLE_ID = (
 )
 CONSOLE_TITLE_ID_RE = re.compile("(?i)" + _CONSOLE_TITLE_ID)
 
+# Gazetteer entries that matched snapshot_r10 val/test names with no train support were removed in R12
+# (tests/test_r12_plugin_hygiene_and_invariance.py lists them).
 GAME_ARCHIVE_RE = re.compile(
     r"(?i)(?:\bNTSC-U\b|\bNTSC-J\b|\[linux-x86\]|\[linux-x64\]|\[win64\]|"
     r"\bInteractive\s+Fiction\b|\bGOG\s+Edition\b|\bLinux\s+Native\b|\((?:Europe|USA|Japan|World)\)\.(?:zip|7z|rar|iso|chd)\b|"