Release Armiger v3.3.0 (v3.0-gold-r13.3) model weights, updated charts, and concise model cards

.gitattributes

@@ -41,3 +41,4 @@ assets/armiger_vs_torrent_classifiers_6dims.png filter=lfs diff=lfs merge=lfs -t
 assets/armiger_categorical_breakdown.png filter=lfs diff=lfs merge=lfs -text
 assets/armiger_vs_llms_overall_and_6dims.png filter=lfs diff=lfs merge=lfs -text
 assets/armiger_vs_llms_cost_comparison.png filter=lfs diff=lfs merge=lfs -text
+assets/armiger_overview.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -21,28 +21,18 @@ tags:
   - cpu-inference
 ---
 
-# Armiger `v3.2.1` (Model Bundle `v3.0.0` / `v3.0-gold-r5`) — 15.7 MB INT8 ONNX CPU Classifier
+# Armiger `v3.3.0` — INT8 ONNX CPU Classifier
 
-**Release:** [`v3.2.1`](https://github.com/spencernorton/armiger/releases/tag/v3.2.1) · **Model Version:** `3.0.0` (`v3.0-gold-r5`) · **Artifact:** `15.7 MB` (`armiger.int8.onnx` / `armiger.onnx`, per-channel asymmetric INT8 with FP32 embeddings) · **CPU latency:** `2.44 ms/item` (`326 items/s` batch-64, M4 Pro CPU) · **License:** Apache-2.0
+**Release:** [`v3.3.0`](https://github.com/spencernorton/armiger/releases/tag/v3.3.0) · **Artifact:** `17.6 MB` INT8 ONNX (`armiger.int8.onnx` / `armiger.onnx`) · **Parameters:** `8.05M` · **License:** Apache-2.0
 
-**Armiger (`NorviTech/armiger`)** is the CPU-only INT8 edition of the 9-head byte-level RoPE Transformer (`8,295,882` parameters). It needs only `numpy` + `onnxruntime` and keeps **`99.90%`** parity with the 32.5 MB FP32 model. Library and container release **`3.2.1`** uses model bundle **`3.0.0`**. For FP32 weights and all 6 plugins (`SwarmSurvivalNet`, `SwarmPriors`, `ZeroCueCatalog`, `AudioLanguageGuard`, `CalibrationAndDHT`, `ArmigerDHTDBSync`), use [`NorviTech/armiger-ultra`](https://huggingface.co/NorviTech/armiger-ultra).
+**Armiger (`NorviTech/armiger`)** is the standalone CPU INT8 edition of the byte-level RoPE Transformer (`numpy` + `onnxruntime` only). For FP32 weights, pre-built `armiger-ultra` containers, and the 6-plugin pipeline, see [`NorviTech/armiger-ultra`](https://huggingface.co/NorviTech/armiger-ultra).
 
-## Neural Outputs & Benchmark Summary
+![Armiger v3.3.0 Overview](assets/armiger_overview.png)
 
-- **9 outputs, one CPU pass:** `category` (11-class), `adult`, `junk`/malware, `anime`, `english_subs`, spoken `lang`, `title_language`, `owner_scope`, and per-byte `span_bio` title/year/episode tags via a 7-tag Viterbi mask (`0` illegal transitions).
-- **INT8 accuracy (all 3 suites):**
-  - **`Suite B LOTO N=1,025`:** **`96.85%`** 6-dimension composite (`95% CI [96.33%, 97.36%]` with plugins) vs. Gemini Flash (`94.56%`), OpenAI GPT Fast Tier (`93.49%`, 5-dim; Junk N/A (Unprompted)), Claude Haiku 4.5 (`92.88%`).
-  - **`W5A-Test N=703` (Rule-3 Gold):** **`97.01%`** 11-class accuracy (`95% Wilson CI [95.47%, 98.04%]`); **`96.87%`** 6-core-head exact match.
-  - **`R5-Test N=996` (7-key zero-leakage):** **`91.16%`** INT8 9-class accuracy (FP32 `91.27%`; `99.90%` parity), **`99.22%`** Title Language (`n=511`), **`99.09%`** English Subtitles (`n=110`), **`98.90%`** Owner Scope (`n=996`), **`90.32%`** BIO Balanced Byte Accuracy (`n=882`), **`85.84%`** all-heads exact match (`n=996`).
-
-![Suite B LOTO Overall & 6-Dimension Comparison](https://huggingface.co/NorviTech/armiger-ultra/resolve/main/assets/fig_v3_vs_llms_1_overall_and_6dims_loto.png)
-
-## Quickstart (Standalone CPU ONNX Runtime)
-
-### Option A — Install the Python package (`v3.2.1`) with verified model download
+## Quickstart
 
 ```bash
-python -m pip install "armiger @ git+https://github.com/spencernorton/armiger.git@v3.2.1"
+python -m pip install "armiger @ git+https://github.com/spencernorton/armiger.git@v3.3.0"
 python -m armiger download --directory ./models-cpu --variant cpu
 ```
 
@@ -62,31 +52,9 @@ res = model.predict({
 print(res["heads"]["category"], res["matching_identity"], res["mondrian_gates"]["passed_all"])
 ```
 
-### Option B — Run directly from a checkout of this Hugging Face repository
-
-```python
-from armiger_inference import ArmigerStandaloneONNX
-
-model = ArmigerStandaloneONNX()  # auto-loads armiger.onnx, vocab.json, calibration.json
-res = model.predict({
-    "name": "Tears.of.Steel.2012.1080p.BluRay.x264-OPEN",
-    "size": 8_500_000_000,
-    "files": [{"path": "Tears.of.Steel.2012.mkv", "size": 8_500_000_000}],
-})
-print(res["heads"]["category"], res["matching_identity"], res["mondrian_gates"]["passed_all"])
-```
-
-## Ready-Made Docker Setups & Integrations (`v3.2.1`)
+## Links & Ecosystem
 
-- **Full FP32 + 6-plugin suite:** [`NorviTech/armiger-ultra`](https://huggingface.co/NorviTech/armiger-ultra)
-- **Core package, containers & evaluation harness (`v3.2.1`):** [`spencernorton/armiger`](https://github.com/spencernorton/armiger) · **License:** Apache-2.0
-  - **[Bitmagnet + Armiger Ultra](https://github.com/spencernorton/armiger/blob/main/examples/bitmagnet/README.md):** Two-line Docker Compose setup (`include: [oci://ghcr.io/spencernorton/armiger-bitmagnet-stack:3.2.1]`) · [Environment-Variable Reference](https://github.com/spencernorton/armiger/blob/main/docs/bitmagnet-configuration.md)
-  - **[Rats Search + Armiger Ultra](https://github.com/spencernorton/armiger/blob/main/examples/rats-search/README.md):** Two-line Docker Compose setup (`include: [oci://ghcr.io/spencernorton/armiger-rats-search-stack:3.2.1]`)
-  - **[Standalone Armiger Ultra HTTP Container](https://github.com/spencernorton/armiger/blob/main/docs/quickstart.md):** Prebuilt multi-arch image `ghcr.io/spencernorton/armiger:3.2.1` with `/v1/classify` and `/healthz`
-  - **[Python API & Component Reference](https://github.com/spencernorton/armiger/blob/main/docs/reference.md)** · **[Evaluation & Limitations](https://github.com/spencernorton/armiger/blob/main/docs/evaluation.md)**
-- **Standalone sidecars & connectors (`v1.1.1`):** [`spencernorton/Armiger-Connectors`](https://github.com/spencernorton/Armiger-Connectors)
-  - **Stock Bitmagnet (`bitmagnet-io/bitmagnet`):** [`bitmagnet/bitmagnet_connector.py`](https://github.com/spencernorton/Armiger-Connectors/blob/main/bitmagnet/bitmagnet_connector.py) — polls untagged torrents via GraphQL, runs vectorized Armiger inference, prunes `.exe`/`.scr`/`.lnk` malware and honeypot traps, writes `armiger-*` tags.
-  - **Stock Rats Search (`librats/rats-search`):** [`rats-search/rats_search_connector.py`](https://github.com/spencernorton/Armiger-Connectors/blob/main/rats-search/rats_search_connector.py) — drop-in REST/SQLite sidecar classifier and safety filter.
-  - **DH-Waypoint `processorapi/v1` plugin** ([`spencernorton/DH-Waypoint`](https://github.com/spencernorton/DH-Waypoint)): [`dh-waypoint/`](https://github.com/spencernorton/Armiger-Connectors/tree/main/dh-waypoint) — admission (`/v1/admit`), batch (`/v1/classify`), 4-tier feedback (`/v1/feedback`).
-  - **Torznab pre-grab proxy (`Prowlarr`/`Sonarr`/`Radarr`/`Lidarr`/`Readarr`):** [`arr-stack/armiger_torznab_proxy.py`](https://github.com/spencernorton/Armiger-Connectors/blob/main/arr-stack/armiger_torznab_proxy.py) — filters malware lures, dead swarms, and unrequested foreign-audio releases before grab.
-  - **Post-import `*Arr`/qBittorrent webhook:** [`arr-stack/armiger_arr_webhook_receiver.py`](https://github.com/spencernorton/Armiger-Connectors/blob/main/arr-stack/armiger_arr_webhook_receiver.py) — `ffprobe` ground truth for local conformal calibration and opt-in anonymous BEP-44/46 updates.
+- **Full FP32 + 6-Plugin Suite:** [`NorviTech/armiger-ultra`](https://huggingface.co/NorviTech/armiger-ultra)
+- **Core Package, Containers & Evaluation (`v3.3.0`):** [`spencernorton/armiger`](https://github.com/spencernorton/armiger) (`ghcr.io/spencernorton/armiger-ultra:3.3.0`)
+- **Indexer Sidecars (Bitmagnet, Rats Search, `*Arr` Torznab):** [`spencernorton/Armiger-Connectors`](https://github.com/spencernorton/Armiger-Connectors)
+- **DH-Waypoint DHT Crawler & Indexer:** [`spencernorton/DH-Waypoint`](https://github.com/spencernorton/DH-Waypoint)

_r12_features_base.py

@@ -0,0 +1,932 @@
+"""Standalone Armiger v2.1 / Armiger Ultra ONNX Featurizer & Inference Runtime (`armiger_inference.py`).
+
+Implements exact feature parity with the Armiger v2.1 training pipeline (`sift/prepare.py` +
+`enrich_side21_v2` 36-dim `stats` vector + `vocab.json` 4,096-extension lookup + CRC32
+digit-folded path-word hashing) with zero external codebase dependencies beyond `numpy`
+and `onnxruntime`.
+
+All release-group and publisher token tables are stored as 8-byte BLAKE2b-64 hex digests
+so zero copyrighted or scene group strings appear in plaintext.
+
+R12 Session 2: derivative-group file-tree features
+(`U_deriv_groups`, `E_episode_keys`, `P_multipart_idx`, `s_max`) are computed by
+`compute_derivative_group_features` and appended to the side vector at
+`side[24..27]`; negated subtitle clauses are stripped before the `side[13]`
+subtitle cue; opaque top-level names gain a `|FILES: ...` primary-media suffix
+in `name_bytes`. Legacy `side[0..23]` semantics are unchanged (only previously
+dead `side[13]` becomes live), so `stats[:36]` remains the legacy R10/R11
+prefix. Training (R12 Sessions 5 & 7) and inference must import the shared
+`SIDE_DIM` / `STATS_DIM` constants below instead of hard-coding `24` / `36`.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import re
+from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
+import zlib
+
+try:
+    import numpy as np
+except ImportError:
+    np = None  # type: ignore[assignment]
+
+SPAN_BIO_CLASSES: Tuple[str, ...] = (
+    "O",
+    "B-TITLE",
+    "I-TITLE",
+    "B-YEAR",
+    "I-YEAR",
+    "B-EP",
+    "I-EP",
+)
+
+# Side/stats dimensionality contract (R12 Session 2). `stats = base_stats + side`.
+BASE_STATS_DIM: int = 12
+LEGACY_SIDE_DIM: int = 24
+SIDE_DIM: int = 28  # 24 legacy slots + 4 derivative-group features at side[24..27]
+N_SIDE: int = SIDE_DIM
+STATS_DIM: int = BASE_STATS_DIM + SIDE_DIM  # 40 (legacy R10/R11 width was 36)
+LEGACY_STATS_DIM: int = BASE_STATS_DIM + LEGACY_SIDE_DIM  # 36
+SIDE_FEATURE_NAMES: Tuple[str, ...] = (
+    "ebook_share", "pdf_share", "m4b_share", "comic_share", "console_share",
+    "app_share", "exec_share", "iso_share", "archive_share", "html_share",
+    "script_ext_present", "trap_flag", "small_video_flag", "subtitle_cue",
+    "sub_only_group", "anime_keyword", "dub_keyword", "game_group",
+    "software_group", "course_keyword", "book_comic_keyword",
+    "lang_english", "lang_non_english", "lang_unknown",
+    "deriv_u_log", "deriv_e_log", "deriv_p_multipart", "deriv_s_max",
+)
+
+NEURAL_HEAD_CLASSES: Dict[str, List[str]] = {
+    "category": [
+        "movie", "tv_show", "xxx", "music", "comic",
+        "game", "audiobook", "software", "ebook", "course", "unknown",
+    ],
+    "adult": ["non_adult", "adult"],
+    "junk": ["clean", "junk"],
+    "anime": ["non_anime", "anime"],
+    "english_subs": ["no_eng_subs", "has_eng_subs", "unknown"],
+    "lang": ["english", "non_english", "multi_or_unknown"],
+    "owner_scope": ["allowed_type", "excluded"],
+    "title_language": ["english_title", "non_english_title"],
+    "span_bio": list(SPAN_BIO_CLASSES),
+}
+
+_VOCAB_EXT_MAP: Optional[Dict[str, int]] = None
+_PREP_KIND_EXTS = {
+    0: frozenset("mkv mp4 avi ts m2ts mts vob wmv mpg mpeg mov flv rmvb rm m4v divx webm 3gp asf f4v ogv mxf m2v bik".split()),
+    1: frozenset("mp3 flac m4a m4b aac ogg opus wav wma ape alac aif aiff aifc ac3 dts mka mpc wv shn mid midi dff dsf".split()),
+    2: frozenset("zip rar 7z gz tgz bz2 xz zst lz lzma tar cab iso img dmg mdf mds nrg wim par par2 z".split()),
+    3: frozenset("exe msi apk ipa dll bat cmd sh vbs ps1 com scr jar deb rpm appimage run lnk".split()),
+    4: frozenset("jpg jpeg png gif webp bmp tif tiff avif jxl heic heif psd ai svg ico tga cr2 nef arw dng raw eps".split()),
+    5: frozenset("pdf epub mobi azw azw3 djvu djv fb2 txt rtf doc docx odt xls xlsx ppt pptx csv chm cbz cbr cb7 html htm mht mhtml md tex lit".split()),
+    6: frozenset("srt ass ssa sub idx vtt sup smi sbv ttml dfxp usf scc stl mks".split()),
+}
+_PREP_EXT_TO_KIND = {e: k for k, es in _PREP_KIND_EXTS.items() for e in es}
+_PREP_SPLIT_ARC_RE = re.compile(r"[rsz]\d{2,3}|\d{3}")
+_PREP_WORD_RE = re.compile(r"[^\W_]+")
+_PREP_DIGIT_RE = re.compile(r"\d")
+_PREP_SAMPLE_RE = re.compile(r"(?<![a-z])samples?(?![a-z])", re.IGNORECASE)
+
+# BLAKE2b-64 digest sets for release-tag disambiguation (zero plaintext group names)
+_SUB_ONLY_GRP_H = frozenset(['00d47045a1f1cd70', '0380c309e464115a', '0665f92d474878ff', '0f8f3809c6074d35', '1bc080c5d14b4eae', '1bf62e9b91086379', '22325081668ed28b', '26503f6826942362', '33b21e80d5dbfa62', '3e370e64b7539495', '4297edae7e25ba02', '4491be5b41a66832', '44e08227cfda9421', '4b956de9c462ee70', '519230ab4d0911f7', '581a8006ea8bd801', '65dfe6849ae4bb0d', '66ced9df20d8f558', '6a437c446b5778d6', '6cff013c3e752ac8', '6d3b6a62beedc878', '7bc52c5f863149cc', '867c636203d0524d', 'a7637cb5c531d8e9', 'b61d75b73d8e0c59', 'bed3322685febfa5', 'c603a601b7cb9d4c', 'd4eaba2bc7ef10d6', 'e20a8d50ddf1aa2e', 'e3fd326207da261c', 'fc94bcdf9fcb0164'])
+_DUAL_DUB_GRP_H = frozenset(['16bdcdbbbd493d9e', '17addcc669201a7b', '1cb486cd76cea8c6', '1cc2f6b1aa24d6f7', '236a71bfa2d47ca3', '24eee113ee4bddb0', '341556a463a4784b', '3658912d4f05f762', '6149de24f7784f27', '627dcb38527b8e4c', '6f09d409143a679c', '727c5e1f0f05ad51', '8b7c320e1df4bf3e', '9e64e0c8c213bf00', 'ac3675ff37aaf11e', 'b2c26515563660f5', 'bd672057ff15b985', 'd9621931df7eb664', 'e20db1736162ba0c', 'e2ee075c6b5545ad', 'eb446df9e0b5f645', 'f7a175e4cf1907fb', 'fe0fe2b14bb48506'])
+_GAME_GRP_H = frozenset(['03f22fe2a782da12', '0ae36a7939ac0be1', '1217fb0deda20335', '1c8f3166691fa2c6', '306372c75c8ceaa2', '32ba70bb6b5ae022', '4509f87fe97d6ed9', '4afe068be7dcf016', '6f7a14ce24f000a0', '7403ff2453c8a173', '7de6d237db23b5fa', '9641051915abdbb6', 'a491e84e39e2064e', 'a65a1816debe0915', 'aa89d2a9d5d18f01', 'aaac60aa2d75341b', 'bb98906accdd6e05', 'c200372b38fb6d26', 'c430ddffd526c993', 'cc81415c4d797870', 'e37a0da20d8d24ac', 'ed5d3b0f00026714', 'ee7b45399bcf968a', 'f0982ea7c2028c50', 'f1737c198253be9d', 'f766dbb74e38db04', 'fbe41c3bbd33ac19'])
+_SW_GRP_H = frozenset(['09455d377a262608', '0e30392b37df5495', '103064b4fea08f1c', '11a120607b793e4c', '158ba6de7392b368', '193a01c7e1bd0f62', '2199b8b3ff553486', '240843438078b817', '2508ee34b17c2225', '2a4eb6e114be0fab', '352836dac99f04b7', '391bd8a58914224a', '4185301675b9d80c', '4472c2744066912a', '4c4684b615a127b2', '522a470219d3a4f1', '5a6bb90382b6c1f6', '5ca7613c608a9ea5', '63f15e4687bfc135', '66a7555e70f0872e', '73d877e885d34562', '77c343b865d05e31', '780409423e866d09', '7e0a43f55a6714fd', '97409999bccb98f4', '996bd865c828c8f9', '9b60cdfff0e2ab1c', 'a330b94802e4b6c6', 'a9c5a9029bc6a596', 'b48e9326bf6316ef', 'c595d125bfd5ebe9', 'c8575232dac0347d', 'd64fa92611ac0eb2', 'e182e241e26cb119', 'e88087f130a6e7d6'])
+_BOOK_COMIC_GRP_H = frozenset(['0cad54552908fa65', '338c3fad71b18311', '5913147687b3c1e5', '712f82b4b85131a0', '7f5fc23af41380b2', '8d8b63a8bb00b7e4', '913bd80742a62e95', 'c00722c39b756d92', 'ecfebbed5476af20', 'ee2807f40b38f779', 'f89c7ccfb7b1338c', 'fdffac028227e18e', 'ffb2c2ead4c7ba7e'])
+_BENIGN_README_EXE_H = frozenset(['062b96e72d602b6e', '9a9f15179701c6ae', 'ddf05591355cf7e0'])
+
+_TOKEN_SCAN_RE = re.compile(r"[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*")
+_SIDE_ANIME_KW_RE = re.compile(
+    r"(?i)\b(?:anime|ova|ona|donghua|aeni|bdrip[ ._-]*1080p[ ._-]*flac|dual[ ._-]*audio[ ._-]*\[?(?:jpn|jap))\b"
+)
+_SIDE_VID_CLAIM_RE = re.compile(
+    r"(?i)\b(?:1080p|720p|2160p|4k|bluray|blu-ray|bdrip|brrip|web-dl|webdl|webrip|hdtv|dvdrip|hdrip|camrip|hdcam|telesync|x264|x265|hevc|avc|h264|h265|s\d{1,2}e\d{1,3}|season[ ._-]*\d+|fc2-?ppv)\b|高清首发|更新至第"
+)
+_SIDE_DECEPTIVE_SUB_STRIP_RE = re.compile(
+    r"(?i)\b(?:eng(?:lish)?|japanese|jap|jpn|spanish|esp|french|fre|german|ger|italian|ita|russian|rus)[ ._-]+(?:hard|soft)?sub(?:s|bed|titled|titles)?\b|"
+    r"\b(?:hard|soft)?sub(?:s|bed|titled|titles)?[ ._-]+(?:eng|english|esp|ja|jpn|fr|de|it|ru)\b|"
+    r"\b(?:m[ ._-]?subs?|multi[ ._-]?subs?|esubs?|vostfr|hardsubs?)\b"
+)
+_SIDE_ANIME_DUB_KW_RE = re.compile(
+    r"(?i)\b(?:dual[ ._-]?audio|dubbed|eng(?:lish)?[ ._-]?dub(?:bed)?|multi[ ._-]?audio)\b"
+)
+_SIDE_SW_APP_TITLE_RE = re.compile(
+    r"(?i)\b(?:v?\d+\.\d+\.\d+|repack|portable|cracked|keygen|patch|patcher|activat(?:ed|or)|"
+    r"multilingual|win(?:32|64)|x64|x86|macos|macosx|android|apk|pc[ ._-]?game|nintendo[ ._-]?switch|ps4|ps5|"
+    r"emulator|driver|firmware|setup|installer|downloader|studio|vst3?|"
+    r"pro[ ._-]+v?\d|ce[ ._-]+v?\d)\b"
+)
+_SIDE_COURSE_RE = re.compile(
+    r"(?i)\b(?:complete[ ._-]+course|video[ ._-]+course|masterclass|bootcamp|tutorial[ ._-]+series|certification[ ._-]+course|hands-on[ ._-]+training)\b"
+)
+_SIDE_BOOK_COMIC_KW_RE = re.compile(
+    r"(?i)\b(?:audiobooks?|audible|m4b|unabridged|narrated[ ._-]?by|ebook|e-book|epub|mobi|azw3|calibre)\b"
+)
+_SIDE_VPN_TRAP_RE = re.compile(
+    r"(?i)免费安装下载vpn|打不开网页|codec[ ._-]?(?:pack|setup|install)|player[ ._-]?setup|instructions?[ ._-]?to[ ._-]?watch"
+)
+_SIDE_CJK_RE = re.compile(r"[\u4e00-\u9fff]")
+_SIDE_EP_ZIP_RE = re.compile(
+    r"(?i)(?:^\[[^\[\]]{2,30}\].*?(?:\s-\s*\d{1,3}\b|\bS\d{1,2}E\d{1,3}\b).*?\b(?:1080p|720p|2160p|480p)\b|"
+    r"\bS\d{1,2}E\d{1,3}\b.*?\b(?:1080p|720p|2160p|480p|WEB-DL|WEBRip|BluRay|BDRip|HDTV|x264|x265|HEVC)\b|"
+    r"\b(?:1080p|720p|2160p|480p|576p|4k)\b.*?\b(?:WEB-DL|WEBRip|BluRay|BDRip|BRRip|HDRip|HDTV|HDCAM|CAMRip|DVDRip|x264|x265|H\.?264|H\.?265|HEVC|AV1|XviD|DivX)\b|"
+    r"\b(?:WEB-DL|WEBRip|BDRip|BRRip|HDRip|HDTV|HDCAM|CAMRip|DVDRip)\b(?:.*?\b(?:x264|x265|H\.?264|H\.?265|HEVC|AV1|XviD|DivX))?)"
+)
+_SIDE_BENIGN_ZIP_RE = re.compile(
+    r"(?i)\b(?:batch|complete|season[ ._-]*\d+|s\d{1,2}[ ._-]*complete|e?\d{1,3}[ ._-]*[~-][ ._-]*e?\d{1,3}|시즌\s*\d+|완결|全集|合集|"
+    r"ost|soundtrack|artbook|scans?|wallpapers?|fonts?|subs?|subtitles?)\b"
+)
+
+
+# --- R12 Session 2: derivative-group file-tree features ---------------------
+# Brief-mandated video set (.mkv .mp4 .avi .ogv .mpg .mpeg .m4v .ts .wmv .mov
+# .webm .vob .iso) plus same-family containers seen in the gold corpus
+# (.m2ts/.mts/.divx/.flv/.rmvb/.3gp/.asf) so primary videos are never missed.
+_DERIV_VIDEO_EXTS = frozenset(
+    "mkv mp4 avi ogv mpg mpeg m4v ts wmv mov webm vob iso m2ts mts divx flv rmvb 3gp asf".split()
+)
+_DERIV_SAMPLE_RE = re.compile(r"(?i)\bsample\b")
+# IA/transcode rendition suffixes stripped repeatedly from a video stem.
+_DERIV_SUFFIX_RE = re.compile(
+    r"(?i)(?:\.(?:ia|512kb|h264|h\.264|x264|hd|sd)|_(?:archive|thumbs|files|512kb|h264|ia))+$"
+)
+_EP_SXE_RE = re.compile(r"(?i)(?<![a-z0-9])s(\d{1,2})[\s._\-]*e(\d{1,3})(?![0-9])")
+_EP_NXN_RE = re.compile(r"(?<![0-9a-zA-Z])(\d{1,2})x(\d{2})(?![0-9a-zA-Z])", re.IGNORECASE)
+_EP_WORD_RE = re.compile(r"(?i)\b(?:episode)[\s._\-]*(\d{1,3})(?![0-9])")
+_EP_SHORT_RE = re.compile(r"(?i)(?<![a-z0-9])ep\.?\s*(\d{1,3})(?![0-9])")
+_EP_BARE_E_RE = re.compile(r"(?i)(?<![a-z0-9])e(\d{1,3})(?![a-z0-9])")
+# Anime fansub dash numbering (`[Group] Show - 01v2 [CRC].mkv`), train-validated in WS-1.
+_EP_DASH_NUM_RE = re.compile(r"\s-\s(\d{1,3})(?:v\d)?(?![0-9a-zA-Z])")
+_SEASON_HINT_RE = re.compile(
+    r"(?i)(?:(?<![a-z0-9])s(\d{1,2})(?![0-9])|\bseason[\s._\-]*(\d{1,2})(?![0-9]))"
+)
+_MULTIPART_TOKEN_RE = re.compile(
+    r"(?i)\b(?:cd|disc|disk|pt|part|side)[\s._\-]*([1-4])\b"
+)
+_VTS_STEM_RE = re.compile(r"(?i)^vts_\d+_\d+$")
+_PILOT_RE = re.compile(r"(?i)\b(?:unaired[\s._\-]*)?pilot\b")
+_YEAR_TOKEN_RE = re.compile(r"(?<![0-9])(?:19[2-9]\d|20[0-2]\d)(?![0-9])")
+# Negated subtitle clauses are removed before the side[13] subtitle cue so
+# "no english subs" / "without eng subs" / "non-english subtitles" cannot fire it.
+_NEGATED_SUB_RE = re.compile(
+    r"(?i)\b(?:no|without|non|none|pas\s+de|kein[e]?|sin)[\s._\-]+"
+    r"(?:[-\w]+[\s._\-]+){0,2}?(?:eng(?:lish)?[\s._\-]+)?"
+    r"(?:sub(?:title)?s?|srt|ass|ssa|cc)\b"
+    r"|\bsub(?:title)?s?[\s:_-]*(?:no|none|n/a|nil|false)\b"
+)
+_SUB_CUE_RE = re.compile(
+    r"(?i)(?:\b(?:eng(?:lish)?|en|hard|soft|multi)[\s._\-]*"
+    r"(?:sub(?:title)?s?|srt|ass|ssa|cc)\b"
+    r"|\b(?:subtitles?|subs|subbed|esubs?|closed[\s._\-]*captions?)\b"
+    r"|\.(?:srt|ass|ssa)\b)"
+)
+_MEDIA_SUMMARY_EXTS = frozenset(
+    set(_DERIV_VIDEO_EXTS)
+    | set("mp3 flac m4b m4a ogg opus epub mobi azw azw3 pdf cbz cbr cb7 "
+          "exe msi apk dmg nsp xci xcz nsz".split())
+)
+_DERIV_LOG_NORM: float = math.log1p(64.0)
+
+
+def _normalize_file_entries(files: Any) -> List[Tuple[str, int]]:
+    """Normalize torrent `files` (dicts / (path, size) tuples / strings) to `(path, size)` pairs."""
+    out: List[Tuple[str, int]] = []
+    for f in files or []:
+        if isinstance(f, Mapping):
+            p = str(f.get("path") or f.get("p") or f.get("name") or "")
+            try:
+                sz = int(f.get("size") or f.get("s") or 0)
+            except (TypeError, ValueError, OverflowError):
+                sz = 0
+        elif isinstance(f, (tuple, list)) and len(f) >= 1:
+            p = str(f[0] or "")
+            try:
+                sz = int(f[1]) if len(f) > 1 else 0
+            except (TypeError, ValueError, OverflowError):
+                sz = 0
+        else:
+            p, sz = str(f or ""), 0
+        if p and "/.____padding_file/" not in p and not p.startswith(".____padding_file"):
+            out.append((p, max(sz, 0)))
+    return out
+
+
+def _deriv_stem_key(parent: str, stem: str) -> Tuple[str, str]:
+    """Collapse transcode renditions of one work to a single derivative-group key."""
+    s = stem
+    for _ in range(4):
+        stripped = _DERIV_SUFFIX_RE.sub("", s)
+        if stripped == s:
+            break
+        s = stripped
+    norm_s = re.sub(r"[\W_]+", " ", s.lower(), flags=re.UNICODE).strip() or s.lower().strip()
+    norm_p = re.sub(r"[\W_]+", " ", parent.lower(), flags=re.UNICODE).strip()
+    return norm_p, norm_s
+
+
+def _episode_keys_from_text(text: str, default_season: Optional[int] = None) -> set:
+    """Distinct episode keys in one path/name string (multipart CD/Part tokens never count)."""
+    keys: set = set()
+    if not text:
+        return keys
+    seasons = {
+        int(g) for m in _SEASON_HINT_RE.finditer(text)
+        for g in m.groups() if g is not None
+    }
+    for m_sxe in _EP_SXE_RE.finditer(text):
+        seasons.add(int(m_sxe.group(1)))
+    for m_nxn in _EP_NXN_RE.finditer(text):
+        seasons.add(int(m_nxn.group(1)))
+    season = seasons.pop() if len(seasons) == 1 else (default_season if not seasons else None)
+
+    def add_bare(num: int) -> None:
+        keys.add(f"s{season:02d}e{num:03d}" if season is not None else f"ep{num:04d}")
+
+    for m in _EP_SXE_RE.finditer(text):
+        keys.add(f"s{int(m.group(1)):02d}e{int(m.group(2)):03d}")
+    for m in _EP_NXN_RE.finditer(text):
+        keys.add(f"s{int(m.group(1)):02d}e{int(m.group(2)):03d}")
+    for m in _EP_WORD_RE.finditer(text):
+        add_bare(int(m.group(1)))
+    for m in _EP_SHORT_RE.finditer(text):
+        add_bare(int(m.group(1)))
+    # Bare `E01` stems (brief's `Ep?` with optional `p`), e.g. `Show.S01/E01.mkv`.
+    # The lookbehind already excludes the `E` inside `S01E01` (digit before it).
+    for m in _EP_BARE_E_RE.finditer(text):
+        add_bare(int(m.group(1)))
+    for m in _EP_DASH_NUM_RE.finditer(text):
+        add_bare(int(m.group(1)))
+    if not keys and _PILOT_RE.search(text):
+        keys.add("pilot")
+    return keys
+
+
+def compute_derivative_group_features(
+    files: Any,
+    raw_name: str = "",
+) -> Tuple[float, float, float, float]:
+    """Compute `(U_deriv_groups, E_episode_keys, P_multipart_idx, s_max)` for a torrent file tree.
+
+    - `U`: unique normalized video derivative stems; IA transcodes of one stem
+      (`.mp4`/`.ogv`/`.ia.mp4`/`.512kb` ...) collapse to one group and all
+      `VIDEO_TS/VTS_*` files collapse to one group.
+    - `E`: distinct episode keys (`SxxExx`, `NxNN`, `Ep N`, `Episode N`, bare
+      `ENN` under a season folder). Pure multipart splits (`CD1/CD2`,
+      `Part 1/2` of one film) contribute `0`; a two-part TV pilot carrying an
+      explicit `SxxExx`/`Pilot`/season marker counts its parts (`E >= 2`).
+    - `P`: `1.0` for a multi-disc/part movie split or `VIDEO_TS` with `E <= 1`.
+    - `s_max`: largest deduplicated primary stem share, using the largest file
+      per derivative stem so IA renditions cannot depress it. Sample files
+      (`sample` token, or `< 15 MB` when total video exceeds `100 MB`) are ignored.
+    """
+    entries = _normalize_file_entries(files)
+    videos: List[Tuple[str, str, str, int]] = []  # (path, parent, stem, size)
+    for path, sz in entries:
+        p_norm = path.replace("\\", "/")
+        parent, _, base = p_norm.rpartition("/")
+        if "." not in base:
+            continue
+        stem, ext = base.rsplit(".", 1)
+        if ext.lower() in _DERIV_VIDEO_EXTS:
+            videos.append((p_norm, parent, stem, sz))
+
+    total_video = sum(sz for _, _, _, sz in videos)
+    kept = [
+        v for v in videos
+        if not _DERIV_SAMPLE_RE.search(v[0].rsplit("/", 1)[-1])
+        and not (0 < v[3] < 15_000_000 and total_video > 100_000_000)
+    ]
+    if kept:
+        videos = kept
+
+    rep_bytes: Dict[Tuple[str, str], int] = {}
+    ep_keys: set = set()
+    part_indices: set = set()
+    has_video_ts = False
+    tv_marker = bool(_EP_SXE_RE.search(raw_name or "") or _PILOT_RE.search(raw_name or "")
+                     or _SEASON_HINT_RE.search(raw_name or ""))
+    title_seasons = {
+        int(g) for m in _SEASON_HINT_RE.finditer(raw_name or "")
+        for g in m.groups() if g is not None
+    } | {int(m.group(1)) for m in _EP_SXE_RE.finditer(raw_name or "")} | {int(m.group(1)) for m in _EP_NXN_RE.finditer(raw_name or "")}
+    title_default_season = next(iter(title_seasons)) if len(title_seasons) == 1 else None
+    ep_keys.update(_episode_keys_from_text(raw_name or "", default_season=title_default_season))
+
+    for p_norm, parent, stem, sz in videos:
+        ep_keys.update(_episode_keys_from_text(p_norm, default_season=title_default_season))
+        part_indices.update(int(m.group(1)) for m in _MULTIPART_TOKEN_RE.finditer(p_norm))
+        if _EP_SXE_RE.search(p_norm) or _PILOT_RE.search(p_norm) or _SEASON_HINT_RE.search(p_norm):
+            tv_marker = True
+        if "/video_ts/" in f"/{p_norm.lower()}" or _VTS_STEM_RE.match(stem):
+            has_video_ts = True
+            key = ("__video_ts__", "")
+        else:
+            key = _deriv_stem_key(parent, stem)
+        rep_bytes[key] = max(rep_bytes.get(key, 0), sz)
+
+    e_count = len(ep_keys)
+    # Two-part TV pilot: explicit TV marker + distinct parts of one episode.
+    if tv_marker and len(part_indices) >= 2 and e_count <= 1:
+        e_count = len(part_indices)
+
+    u_count = len(rep_bytes)
+    p_idx = 1.0 if (has_video_ts or len(part_indices) >= 2) and e_count <= 1 else 0.0
+    rep_total = sum(rep_bytes.values())
+    if u_count == 0:
+        s_max = 0.0
+    elif rep_total > 0:
+        s_max = max(rep_bytes.values()) / rep_total
+    else:  # sizes unknown: equal-share assumption over derivative groups
+        s_max = 1.0 / u_count
+    return float(u_count), float(e_count), float(p_idx), float(s_max)
+
+
+def primary_media_file_summary(files: Any, top_n: int = 3) -> str:
+    """Top-`top_n` largest primary media relative paths, ` ; `-joined (largest first)."""
+    media = [
+        (p, sz) for p, sz in _normalize_file_entries(files)
+        if "." in p.rsplit("/", 1)[-1]
+        and p.rsplit("/", 1)[-1].rsplit(".", 1)[-1].lower() in _MEDIA_SUMMARY_EXTS
+    ]
+    media.sort(key=lambda x: -x[1])
+    return " ; ".join(p for p, _ in media[:top_n])
+
+
+def build_enriched_name_text(name: str, files: Any, max_bytes: int = 256) -> str:
+    """Append |FILES: <top-3 media basenames> when name is opaque or hides multi-episode files."""
+    summary = primary_media_file_summary(files, top_n=3)
+    if not summary:
+        return name
+    _, e_count, _, _ = compute_derivative_group_features(files, name)
+    name_has_ep = bool(_episode_keys_from_text(name))
+    is_opaque_slug = not bool(re.search(r"[A-Za-z]{3,}", name))
+    hidden_ep_pack = (e_count >= 2 and not name_has_ep)
+    if not (is_opaque_slug or hidden_ep_pack):
+        return name
+    basenames = " ; ".join(
+        p.rsplit("/", 1)[-1] for p in summary.split(" ; ")
+    )
+    return f"{name} |FILES: {basenames}"
+
+
+def _h64(s: str) -> str:
+    return hashlib.blake2b(s.strip().lower().encode("utf-8"), digest_size=8).hexdigest()
+
+
+def _extract_token_hashes(text: str) -> frozenset[str]:
+    toks = [m.group(0).lower() for m in _TOKEN_SCAN_RE.finditer(text)]
+    out = {_h64(t) for t in toks}
+    for i in range(len(toks) - 1):
+        out.add(_h64(f"{toks[i]} {toks[i + 1]}"))
+    return frozenset(out)
+
+
+_VOCAB_CACHE_BY_PATH: Dict[str, Dict[str, int]] = {}
+
+
+def _get_vocab_ext_map(vocab_path: Optional[Path] = None) -> Dict[str, int]:
+    global _VOCAB_EXT_MAP
+    if vocab_path is not None:
+        vp = Path(vocab_path)
+        if vp.exists():
+            key = str(vp.resolve())
+            if key not in _VOCAB_CACHE_BY_PATH:
+                data = json.loads(vp.read_text(encoding="utf-8"))
+                _VOCAB_CACHE_BY_PATH[key] = {e: i + 1 for i, e in enumerate(data.get("exts", []))}
+            _VOCAB_EXT_MAP = _VOCAB_CACHE_BY_PATH[key]
+            return _VOCAB_EXT_MAP
+    if vocab_path is None and _VOCAB_EXT_MAP is not None and len(_VOCAB_EXT_MAP) > 64:
+        return _VOCAB_EXT_MAP
+    vpath = Path(__file__).resolve().with_name("vocab.json")
+    if not vpath.exists() and os.environ.get("ARMIGER_MODEL_DIR"):
+        vpath = Path(os.environ["ARMIGER_MODEL_DIR"]) / "vocab.json"
+    if vpath.exists():
+        key = str(vpath.resolve())
+        if key not in _VOCAB_CACHE_BY_PATH:
+            data = json.loads(vpath.read_text(encoding="utf-8"))
+            _VOCAB_CACHE_BY_PATH[key] = {e: i + 1 for i, e in enumerate(data.get("exts", []))}
+        _VOCAB_EXT_MAP = _VOCAB_CACHE_BY_PATH[key]
+    else:
+        _VOCAB_EXT_MAP = {
+            "mp3": 2, "mp4": 3, "mkv": 4, "avi": 7, "srt": 10, "zip": 12,
+            "rar": 17, "exe": 23, "flac": 24, "png": 25, "dll": 31, "m4b": 53,
+            "epub": 81, "cbz": 96, "lnk": 150, "scr": 310,
+        }
+    return _VOCAB_EXT_MAP
+
+
+def _hash_ext(ext: str) -> int:
+    if not ext:
+        return 4096
+    return _get_vocab_ext_map().get(ext.lower(), 4096)
+
+
+def _hash_word(w: str) -> int:
+    if not w:
+        return 0
+    folded = _PREP_DIGIT_RE.sub("0", w.lower())
+    return (zlib.crc32(folded.encode("utf-8")) % 32767) + 1
+
+
+def _log2_size_bucket(sz: int) -> int:
+    return min(47, max(int(sz), 1).bit_length() - 1)
+
+
+def _prep_split_path(path: str) -> Tuple[str, str, str, int]:
+    p_norm = path.replace("\\", "/")
+    parent, _, base = p_norm.rpartition("/")
+    i = base.rfind(".")
+    ext = base[i + 1:].lower() if i > 0 else ""
+    if len(ext) <= 10 and ext.isascii() and ext.isalnum():
+        stem = base[:i]
+    else:
+        ext, stem = "", base
+    return parent.rpartition("/")[2], stem, ext, p_norm.count("/")
+
+
+def _prep_path_words(parent: str, stem: str) -> List[int]:
+    p_words = [_hash_word(w) for w in _PREP_WORD_RE.findall(parent.lower())][-2:] if parent else []
+    s_words = [_hash_word(w) for w in _PREP_WORD_RE.findall(stem.lower())][-(4 - len(p_words)):]
+    res = p_words + s_words
+    while len(res) < 4:
+        res.append(0)
+    return res[:4]
+
+
+def encode_torrent_features(
+    row: Mapping[str, Any],
+    max_name_len: int = 256,
+    max_files: int = 64,
+) -> Dict[str, Any]:
+    """Encode a torrent metadata dictionary into the exact ONNX tensor inputs for Armiger v2.1."""
+    name = str(row.get("name") or row.get("title") or "")
+
+    raw_files = row.get("files") or []
+    try:
+        total_size = max(0, int(row.get("size") or 0))
+    except (TypeError, ValueError, OverflowError):
+        total_size = 0
+    all_items: List[Tuple[str, int]] = _normalize_file_entries(raw_files)
+    all_items.sort(key=lambda x: -x[1])
+    items: List[Tuple[str, int]] = all_items[:max_files]
+    if not items and (row.get("ext") or row.get("extension") or "." in name):
+        items.append((name, total_size))
+
+    # R12: opaque/folder names expose their primary media filenames to the
+    # byte/char/word encoders; derivative-group features use the full tree.
+    name_text = build_enriched_name_text(name, all_items or items, max_bytes=max_name_len)
+    b_name = name_text.encode("utf-8", "replace")
+    if len(b_name) > max_name_len:
+        b_name = b_name[:max_name_len].decode("utf-8", "ignore").encode("utf-8")
+    raw_bytes = list(b_name) if b_name else [32]
+    deriv_features = compute_derivative_group_features(all_items or items, name)
+
+    ext_map = _get_vocab_ext_map()
+    exts: List[int] = []
+    sizes: List[int] = []
+    depths: List[int] = []
+    words_list: List[List[int]] = []
+    f_exts_str: List[str] = []
+
+    kbytes = [0.0] * 8
+    kcount = [0] * 8
+    has_sample = False
+
+    for path, sz in items:
+        parent, stem, ext, depth = _prep_split_path(path)
+        f_exts_str.append(ext)
+        exts.append(ext_map.get(ext, 4096))
+        sizes.append(_log2_size_bucket(sz))
+        depths.append(min(depth, 7))
+        words_list.append(_prep_path_words(parent, stem))
+        k = _PREP_EXT_TO_KIND.get(ext)
+        if k is None:
+            k = 2 if _PREP_SPLIT_ARC_RE.fullmatch(ext) else 7
+        kbytes[k] += max(sz, 0)
+        kcount[k] += 1
+        has_sample = has_sample or (_PREP_SAMPLE_RE.search(path) is not None)
+
+    tot_k = sum(kbytes)
+    weights = kbytes if tot_k > 0 else [float(c) for c in kcount]
+    wsum = sum(weights)
+    try:
+        raw_fc = max(0, int(row.get("file_count") or 0))
+    except (TypeError, ValueError, OverflowError):
+        raw_fc = 0
+    count = max(raw_fc, len(all_items), len(items))
+    biggest = max((max(s, 0) for _, s in items), default=0)
+    max_share = (biggest / tot_k if tot_k > 0 else (1.0 / len(items) if items else 0.0))
+
+    base_stats = [
+        math.log1p(max(count, 0)),
+        math.log1p(max(total_size if total_size > 0 else int(tot_k), 0)),
+    ]
+    base_stats += [w / wsum if wsum > 0 else 0.0 for w in weights]
+    base_stats += [max_share, float(has_sample)]
+
+    side = [0.0] * SIDE_DIM
+    n_f = float(max(1, len(items)))
+
+    m_grp = re.match(r"^\[([^\[\]]{2,30})\]", name)
+    grp_lc = m_grp.group(1).strip().lower() if m_grp else ""
+    grp_h = _h64(grp_lc) if grp_lc else ""
+    title_tok_h = _extract_token_hashes(name)
+
+    has_sub_grp = (grp_h in _SUB_ONLY_GRP_H) or bool(title_tok_h & _SUB_ONLY_GRP_H)
+    has_dub_grp = (grp_h in _DUAL_DUB_GRP_H) or bool(title_tok_h & _DUAL_DUB_GRP_H)
+    has_game_grp = bool(title_tok_h & _GAME_GRP_H)
+    has_sw_grp = bool(title_tok_h & _SW_GRP_H)
+    has_book_grp = bool(title_tok_h & _BOOK_COMIC_GRP_H)
+
+    if items:
+        ebk_set = {"epub", "mobi", "azw3", "azw", "djvu", "fb2", "lit", "iba"}
+        pdf_set = {"pdf"}
+        m4b_set = {"m4b", "aa", "aax"}
+        com_set = {"cbz", "cbr", "cb7", "cbt"}
+        con_set = {"nsp", "xci", "xcz", "nsz", "wbfs", "rvz", "gcz", "cia", "3ds", "vpk", "ps4", "fpkg"}
+        app_set = {"dmg", "pkg", "apk", "ipa", "deb", "rpm", "appimage"}
+        exe_dll_set = {"exe", "msi", "bat", "cmd", "sh", "com", "dll"}
+        iso_set = {"iso", "bin", "cue", "mdf", "mds", "nrg", "img"}
+        arc_set = {"rar", "zip", "7z", "tar", "gz", "xz", "bz2", "001"}
+        htm_set = {"html", "htm", "url", "mht", "torrent"}
+        scr_set = {"scr", "lnk", "vbs", "hta", "pif", "ps1", "wsf", "reg"}
+        vid_set = {"mkv", "mp4", "avi", "ts", "m2ts", "wmv", "mov", "webm", "flv", "mpg", "mpeg", "m4v", "vob", "ogv", "rmvb", "3gp", "asf", "divx"}
+        bd_game_benign = {"vcdiff", "apk", "bdmv", "clpi", "mpls", "ifo", "bup", "vob", "npa", "vpk", "pck", "umd", "pak", "xp3", "rgss3a", "wolf", "nsp", "xci", "wbfs"}
+
+        side[0] = sum(1 for e in f_exts_str if e in ebk_set) / n_f
+        side[1] = sum(1 for e in f_exts_str if e in pdf_set) / n_f
+        side[2] = sum(1 for e in f_exts_str if e in m4b_set) / n_f
+        side[3] = sum(1 for e in f_exts_str if e in com_set) / n_f
+        side[4] = sum(1 for e in f_exts_str if e in con_set) / n_f
+        side[5] = sum(1 for e in f_exts_str if e in app_set) / n_f
+
+        vc = bool(_SIDE_VID_CLAIM_RE.search(name) or _SIDE_ANIME_KW_RE.search(name) or has_sub_grp or has_dub_grp)
+        has_any_vid_inf = any(e in vid_set for e in f_exts_str)
+        has_renpy_structure = (
+            not vc
+            and not has_any_vid_inf
+            and any(
+                p_i.replace("\\", "/").lower().endswith((".rpa", ".rpyb")) and int(sz_i or 0) >= 65536
+                for p_i, sz_i in items
+            )
+        )
+        renpy_say_re = re.compile(r"(?i)(?:^|/)lib/(?:py\d+-)?windows-[^/]+/say\.vbs$")
+
+        n_real_exec_dll = 0
+        has_real_exe = False
+        has_dll = False
+        has_scr_trap = False
+        has_oversized_lnk = False
+        has_root_launcher = False
+        has_unconditional_trap_ext = False
+        has_any_scr_ext = False
+        vid_depths: List[int] = []
+
+        for (p_i, _), e_str, s_b, d_i, w_i in zip(items, f_exts_str, sizes, depths, words_list):
+            p_posix = p_i.replace("\\", "/")
+            if has_renpy_structure and renpy_say_re.search(p_posix):
+                continue
+            if e_str in scr_set:
+                has_any_scr_ext = True
+            if e_str in {"scr", "vbs", "vbe", "hta", "pif", "wsf", "wsh", "cpl"}:
+                has_unconditional_trap_ext = True
+            p_tok_h = _extract_token_hashes(p_i)
+            is_benign_stub = (e_str == "exe") and (s_b < 15 or 16570 in w_i or bool(p_tok_h & _BENIGN_README_EXE_H))
+            if e_str in exe_dll_set and not is_benign_stub:
+                n_real_exec_dll += 1
+            if e_str == "exe" and not is_benign_stub and s_b >= 15:
+                has_real_exe = True
+                if d_i == 0:
+                    has_root_launcher = True
+            elif e_str == "dll":
+                has_dll = True
+            if e_str in {"scr", "lnk", "hta", "vbs", "pif", "ps1", "wsf", "cmd", "com", "one", "xll", "xlam"} and s_b >= 12:
+                has_scr_trap = True
+                if d_i == 0:
+                    has_root_launcher = True
+                if e_str == "lnk" and s_b >= 15:
+                    has_oversized_lnk = True
+            if e_str in vid_set:
+                vid_depths.append(d_i)
+
+        side[6] = n_real_exec_dll / n_f
+        side[7] = sum(1 for e in f_exts_str if e in iso_set) / n_f
+        side[8] = sum(1 for e in f_exts_str if e in arc_set) / n_f
+        side[9] = sum(1 for e in f_exts_str if e in htm_set) / n_f
+        side[10] = 1.0 if has_any_scr_ext else 0.0
+
+        is_sw_or_game = bool(
+            has_game_grp
+            or has_sw_grp
+            or (not vc and _SIDE_SW_APP_TITLE_RE.search(name))
+            or any(e in bd_game_benign for e in f_exts_str)
+        )
+        vid_share = base_stats[2]
+        flagged = has_unconditional_trap_ext
+        if not is_sw_or_game:
+            if vc and has_real_exe and has_dll:
+                flagged = True
+            elif vc and len(vid_depths) >= 1 and (has_real_exe or has_root_launcher or has_scr_trap):
+                flagged = True
+            elif (vc or len(vid_depths) > 0) and has_oversized_lnk:
+                flagged = True
+            elif vc and vid_share == 0.0 and (has_real_exe or has_scr_trap):
+                flagged = True
+            elif len(items) <= 2 and any(e in ("zip", "zipx", "rar", "7z") for e in f_exts_str) and vid_share == 0.0:
+                if _SIDE_EP_ZIP_RE.search(name) and not _SIDE_BENIGN_ZIP_RE.search(name):
+                    flagged = True
+            elif len(items) <= 2 and any(e in ("iso", "img", "vhd", "vhdx", "udf") for e in f_exts_str) and vid_share == 0.0:
+                name_stem = re.sub(r"\.(?:iso|img|vhd|vhdx|udf|dmg)$", "", name.strip(), flags=re.IGNORECASE)
+                if _SIDE_EP_ZIP_RE.search(name_stem) and not re.search(r"(?i)\b(?:dvd|bd25|bd50|remux|untouched|pal|ntsc|iso)\b", name_stem):
+                    flagged = True
+
+        if flagged or _SIDE_VPN_TRAP_RE.search(name) or (vc and vid_share == 0.0 and (side[6] > 0 or side[9] > 0 or side[10] > 0)):
+            side[11] = 1.0
+        if vc and vid_share > 0 and 0 < base_stats[1] < 14.22:
+            side[12] = 1.0
+
+    # R12: strip negated subtitle clauses ("no english subs", ...) before the
+    # side[13] subtitle cue; previously side[13] was never populated at all.
+    if _SUB_CUE_RE.search(_NEGATED_SUB_RE.sub(" ", name)):
+        side[13] = 1.0
+
+    ag = bool(_SIDE_ANIME_KW_RE.search(name)) or has_sub_grp or has_dub_grp
+    if ag:
+        side[15] = 1.0
+    clean_audio_name = _SIDE_DECEPTIVE_SUB_STRIP_RE.sub(" ", name)
+    clean_tok_h = _extract_token_hashes(clean_audio_name)
+    ad = bool(_SIDE_ANIME_DUB_KW_RE.search(clean_audio_name)) or (grp_h in _DUAL_DUB_GRP_H) or bool(clean_tok_h & _DUAL_DUB_GRP_H)
+    if ad:
+        side[16] = 1.0
+    if (grp_h in _SUB_ONLY_GRP_H) and not ad:
+        side[14] = 1.0
+    if has_game_grp:
+        side[17] = 1.0
+    if has_sw_grp and not _SIDE_CJK_RE.search(name):
+        side[18] = 1.0
+    if _SIDE_COURSE_RE.search(name) and not ag:
+        side[19] = 1.0
+    if _SIDE_BOOK_COMIC_KW_RE.search(name) or has_book_grp:
+        side[20] = 1.0
+
+    lang_str = (row.get("language") or "").strip().lower()
+    if lang_str in ("ja", "ru", "fr", "es", "de", "it", "pt", "zh", "ko", "hi", "pl", "nl", "tr", "ar") or _SIDE_CJK_RE.search(name) or ((grp_h in _SUB_ONLY_GRP_H) and not ad):
+        side[22] = 1.0
+    elif lang_str in ("en", "eng", "english") or ad:
+        side[21] = 1.0
+    else:
+        side[23] = 1.0
+
+    # R12 derivative-group features (raw counts stay in `deriv_features`;
+    # the network sees bounded log-normalized U/E, binary P, raw s_max).
+    _u, _e, _p, _smax = deriv_features
+    side[24] = min(1.0, math.log1p(_u) / _DERIV_LOG_NORM)
+    side[25] = min(1.0, math.log1p(_e) / _DERIV_LOG_NORM)
+    side[26] = float(_p)
+    side[27] = float(_smax)
+
+    return {
+        "name_bytes": raw_bytes,
+        "ext": exts if exts else [0],
+        "size": sizes if sizes else [0],
+        "depth": depths if depths else [0],
+        "words": words_list if words_list else [[0, 0, 0, 0]],
+        "stats": base_stats + side,
+        "deriv_features": deriv_features,
+        "name_text": name_text,
+    }
+
+
+def build_onnx_batch_inputs(
+    rows: Sequence[Mapping[str, Any]],
+    max_name_len: int = 256,
+    max_files: int = 64,
+    stats_dim: Optional[int] = None,
+) -> Dict[str, np.ndarray]:
+    """Collate a sequence of torrent dicts into padded NumPy arrays for ONNX Runtime.
+
+    `stats_dim` defaults to `STATS_DIM` (40). Pass a legacy checkpoint's width
+    (e.g. `36`) to emit the legacy `stats` prefix during the R12 transition;
+    `ArmigerStandaloneONNX.predict_batch` does this automatically from the
+    loaded session's `stats` input shape.
+    """
+    encoded = [encode_torrent_features(r, max_name_len=max_name_len, max_files=max_files) for r in rows]
+    bsz = len(encoded)
+    max_l = max(len(e["name_bytes"]) for e in encoded)
+    max_f = max(len(e["ext"]) for e in encoded)
+    width = STATS_DIM if stats_dim is None else int(stats_dim)
+
+    name_b = np.zeros((bsz, max_l), dtype=np.int64)
+    name_l = np.zeros((bsz,), dtype=np.int64)
+    ext_t = np.zeros((bsz, max_f), dtype=np.int32)
+    size_t = np.zeros((bsz, max_f), dtype=np.int64)
+    depth_t = np.zeros((bsz, max_f), dtype=np.int64)
+    words_t = np.zeros((bsz, max_f, 4), dtype=np.int32)
+    stats_t = np.zeros((bsz, width), dtype=np.float32)
+
+    for i, e in enumerate(encoded):
+        lb = len(e["name_bytes"])
+        lf = len(e["ext"])
+        name_b[i, :lb] = e["name_bytes"]
+        name_l[i] = lb
+        ext_t[i, :lf] = e["ext"]
+        size_t[i, :lf] = e["size"]
+        depth_t[i, :lf] = e["depth"]
+        words_t[i, :lf, :] = e["words"]
+        stats_t[i, : min(width, len(e["stats"]))] = e["stats"][:width]
+
+    return {
+        "name_bytes": name_b,
+        "name_len": name_l,
+        "ext": ext_t,
+        "size": size_t,
+        "depth": depth_t,
+        "words": words_t,
+        "stats": stats_t,
+    }
+
+
+def _softmax(logits: np.ndarray) -> np.ndarray:
+    shifted = logits - np.max(logits, axis=-1, keepdims=True)
+    exps = np.exp(shifted)
+    return exps / np.sum(exps, axis=-1, keepdims=True)
+
+
+_DEFAULT_MONDRIAN_THRESHOLDS: Dict[str, float] = {"adult": 0.5451, "junk": 0.1010, "owner_scope": 0.4770}
+
+
+def _mondrian_value(v: Any) -> Optional[float]:
+    return float(v) if isinstance(v, (int, float)) and not isinstance(v, bool) and 0.0 < float(v) < 1.0 else None
+
+
+def load_mondrian_thresholds(calibration_path: str | Path | None) -> Tuple[Dict[str, float], Dict[str, Dict[str, float]]]:
+    """(global gate thresholds, per-gate strata) from `calibration.json`; defaults only where nothing is fitted.
+
+    Same precedence as `calibration_and_dht.ArmigerCalibrator`: `mondrian_thresholds[gate]` (a dict replaces the
+    legacy block entirely), else legacy `mondrian_conformal_thresholds[gate]["threshold" | "threshold_*"]`;
+    strata from `mondrian_stratified_thresholds[gate]["strata"][<category>]` (fitted per predicted category).
+    """
+    thresholds = dict(_DEFAULT_MONDRIAN_THRESHOLDS)
+    strata: Dict[str, Dict[str, float]] = {}
+    try:
+        cfg = json.loads(Path(calibration_path).read_text(encoding="utf-8")) if calibration_path else {}
+    except (OSError, ValueError):
+        cfg = {}
+    if not isinstance(cfg, dict):
+        return thresholds, strata
+    flat = cfg.get("mondrian_thresholds")
+    if not isinstance(flat, dict):
+        legacy = cfg.get("mondrian_conformal_thresholds")
+        flat = {}
+        for gate, block in (legacy.items() if isinstance(legacy, dict) else ()):
+            if isinstance(block, dict):
+                keys = ["threshold"] + sorted(k for k in block if str(k).startswith("threshold_"))
+                flat[gate] = next((block[k] for k in keys if _mondrian_value(block.get(k)) is not None), None)
+            else:
+                flat[gate] = block
+    for gate in thresholds:
+        v = _mondrian_value(flat.get(gate, flat.get("scope") if gate == "owner_scope" else None))
+        if v is not None:
+            thresholds[gate] = v
+    raw_strata = cfg.get("mondrian_stratified_thresholds")
+    for gate, block in (raw_strata.items() if isinstance(raw_strata, dict) else ()):
+        per = block.get("strata") if isinstance(block, dict) else None
+        if isinstance(per, dict):
+            g_key = "owner_scope" if gate == "scope" else str(gate)
+            strata[g_key] = {str(k): t for k, v in per.items() if (t := _mondrian_value(v)) is not None}
+    return thresholds, strata
+
+
+class ArmigerStandaloneONNX:
+    """Self-contained ONNX Runtime classifier for `NorviTech/armiger` and `NorviTech/armiger-ultra`."""
+
+    def __init__(
+        self,
+        onnx_path: Optional[str | Path] = None,
+        vocab_path: Optional[str | Path] = None,
+        calibration_path: Optional[str | Path] = None,
+    ) -> None:
+        import onnxruntime as ort
+
+        base = Path(__file__).resolve().parent
+        if onnx_path is None:
+            for cand in ("armiger.onnx", "armiger.int8.onnx", "armiger_ultra.fp32.onnx"):
+                if (base / cand).exists():
+                    onnx_path = base / cand
+                    break
+        if onnx_path is None:
+            raise FileNotFoundError("Could not find armiger.onnx or armiger_ultra.fp32.onnx")
+        self.onnx_path = Path(onnx_path)
+        default_vocab = base / "vocab.json"
+        if not default_vocab.exists() and self.onnx_path.with_name("vocab.json").exists():
+            default_vocab = self.onnx_path.with_name("vocab.json")
+        self.vocab_path = Path(vocab_path) if vocab_path else default_vocab
+        _get_vocab_ext_map(self.vocab_path)
+        default_cal = base / "calibration.json"
+        if not default_cal.exists() and self.onnx_path.with_name("calibration.json").exists():
+            default_cal = self.onnx_path.with_name("calibration.json")
+        self.calibration_path = Path(calibration_path) if calibration_path else default_cal
+        self.mondrian_thresholds, self.mondrian_strata = load_mondrian_thresholds(self.calibration_path)
+        self.session = ort.InferenceSession(str(self.onnx_path), providers=["CPUExecutionProvider"])
+        self.head_names = [o.name for o in self.session.get_outputs()]
+
+    @staticmethod
+    def _apply_v3_post_neural_guard(row: Mapping[str, Any], item_res: Dict[str, Any]) -> Dict[str, Any]:
+        return _apply_v3_post_neural_guard(row, item_res)
+
+    def mondrian_threshold(self, gate: str, stratum: Optional[str] = None) -> float:
+        """Stratified Mondrian threshold for `gate` (per predicted category when fitted, else global)."""
+        per = self.mondrian_strata.get(gate, {})
+        if stratum is not None and str(stratum) in per:
+            return per[str(stratum)]
+        return self.mondrian_thresholds[gate]
+
+    def _session_stats_dim(self) -> int:
+        """`stats` width expected by the loaded checkpoint (legacy 36 or R12 40)."""
+        try:
+            for inp in self.session.get_inputs():
+                if inp.name == "stats" and len(inp.shape) == 2 and isinstance(inp.shape[1], int):
+                    return int(inp.shape[1])
+        except Exception:
+            pass
+        return STATS_DIM
+
+    def predict_batch(self, rows: Sequence[Mapping[str, Any]]) -> List[Dict[str, Any]]:
+        feed = build_onnx_batch_inputs(rows, stats_dim=self._session_stats_dim())
+        raw_outs = self.session.run(self.head_names, feed)
+        logits_by_head = dict(zip(self.head_names, raw_outs))
+        results: List[Dict[str, Any]] = []
+        for i in range(len(rows)):
+            item_res: Dict[str, Any] = {"heads": {}, "probabilities": {}}
+            for h, arr in logits_by_head.items():
+                vec = arr[i].astype(np.float64)
+                if vec.ndim == 2:
+                    # 3D batch tensor (e.g. span_bio [B, 256, 7]) -> 2D per-item [256, 7]
+                    shifted = vec - np.max(vec, axis=-1, keepdims=True)
+                    exps = np.exp(shifted)
+                    probs_2d = exps / np.maximum(1e-12, np.sum(exps, axis=-1, keepdims=True))
+                    raw_nm = str(rows[i].get("name") or rows[i].get("title") or "")
+                    try:
+                        try:
+                            from byte_span_extractor import decode_bio_logits_viterbi, decode_bio_tags_to_spans
+                        except ImportError:
+                            from byte_span_extractor import decode_bio_logits_viterbi, decode_bio_tags_to_spans
+                        raw_b = raw_nm.encode("utf-8", errors="replace")[: vec.shape[0]]
+                        tag_ids = [int(x) for x in decode_bio_logits_viterbi(vec, raw_b).tolist()]
+                    except Exception:
+                        tag_ids = [int(x) for x in np.argmax(probs_2d, axis=-1).tolist()]
+                    classes = NEURAL_HEAD_CLASSES.get(
+                        h,
+                        list(SPAN_BIO_CLASSES),
+                    )
+                    tag_labels = [classes[idx_c] if idx_c < len(classes) else str(idx_c) for idx_c in tag_ids]
+                    item_res["heads"][h] = tag_labels
+                    mean_probs = np.mean(probs_2d, axis=0)
+                    item_res["probabilities"][h] = {
+                        classes[k]: round(float(mean_probs[k]), 6) for k in range(min(len(classes), len(mean_probs)))
+                    }
+                    try:
+                        item_res["span_bio"] = decode_bio_tags_to_spans(raw_nm, tag_ids)
+                    except Exception:
+                        item_res["span_bio"] = {"tag_ids": tag_ids, "tags": tag_labels}
+                    continue
+                probs = _softmax(vec)
+                classes = NEURAL_HEAD_CLASSES.get(h, [str(k) for k in range(len(probs))])
+                idx_c = int(np.argmax(probs))
+                item_res["heads"][h] = classes[idx_c] if idx_c < len(classes) else str(idx_c)
+                item_res["probabilities"][h] = {
+                    classes[k]: round(float(probs[k]), 6) for k in range(min(len(classes), len(probs)))
+                }
+            self._apply_v3_post_neural_guard(rows[i], item_res)
+            p_junk = item_res["probabilities"].get("junk", {}).get("junk", 0.0)
+            p_adult = item_res["probabilities"].get("adult", {}).get("adult", 0.0)
+            # Calibrated excluded probability is kept as-is: the conformal gate (not the argmax label) decides.
+            p_excl = item_res["probabilities"].get("owner_scope", {}).get("excluded", 0.0)
+            stratum = item_res["heads"].get("category")
+            thr = {g: self.mondrian_threshold(g, stratum) for g in ("adult", "junk", "owner_scope")}
+            item_res["p_junk"] = p_junk
+            item_res["mondrian_gates"] = {
+                "adult_flagged": bool(p_adult >= thr["adult"]),
+                "junk_flagged": bool(p_junk >= thr["junk"]),
+                "scope_excluded": bool(p_excl >= thr["owner_scope"]),
+                "passed_all": bool(p_adult < thr["adult"] and p_junk < thr["junk"] and p_excl < thr["owner_scope"]),
+                "thresholds": thr,
+                "owner_scope_stratum": stratum,
+            }
+            results.append(item_res)
+        return results
+
+    def predict(self, row: Mapping[str, Any]) -> Dict[str, Any]:
+        return self.predict_batch([row])[0]
+
+
+ArmigerONNXClassifier = ArmigerStandaloneONNX
+
+
+def _apply_v3_post_neural_guard(row, result):
+    return result

armiger.int8.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a0dab886be6252739d4c89ce01d65d8d2135204beaec6b00159d038cf420f329
-size 15721824
+oid sha256:c0e96936038988c7465b7fe041c4dc3c92df5a8cb4f56c2666271cd4d3e79420
+size 17599636

armiger.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a0dab886be6252739d4c89ce01d65d8d2135204beaec6b00159d038cf420f329
-size 15721824
+oid sha256:c0e96936038988c7465b7fe041c4dc3c92df5a8cb4f56c2666271cd4d3e79420
+size 17599636

armiger_dht_rsi.py

@@ -45,14 +45,14 @@ from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
 
 import sys
-_THIS_DIR = pathlib.Path(__file__).resolve().parent
-if str(_THIS_DIR) not in sys.path:
-    sys.path.insert(0, str(_THIS_DIR))
 
 from dht_rsi_models_and_privacy import (
+    AcyclicReleaseEnvelope,
     AnonymityGuard,
     AnonymityViolationError,
     AnonymizedTelemetryRecord,
+    AuthenticatedConformalBaseline,
+    BenchmarkAttestationPredicate,
     BlindedTitleStem,
     BundleFormat,
     CanaryItem,
@@ -62,6 +62,9 @@ from dht_rsi_models_and_privacy import (
     ContinuousAggregationResult,
     ContinuousDeltaSubmission,
     DHTRSIMode,
+    DSSE_TYPE_ATTESTATION_V2,
+    DSSE_TYPE_BASELINE_V1,
+    DSSE_TYPE_RELEASE_V2,
     EncryptedTelemetryBundle,
     MediaCategory,
     PeerAttestation,
@@ -73,6 +76,7 @@ from dht_rsi_models_and_privacy import (
     VerifiedObservation,
     ZeroCueCatalogDelta,
     _bep44_canonical_sign_buffer,
+    dsse_pae,
     pure_laplace_noise,
     resolve_opt_in_sharing,
 )
@@ -91,6 +95,7 @@ from dht_rsi_crypto_and_adapters import (
     _OptInAdapterBase,
 )
 from dht_rsi_verification import (
+    AcyclicProvenanceVerifier,
     AuthoritativeASNVerifier,
     PhysicalGroundTruthVerifier,
     SafeFormatValidator,
@@ -136,9 +141,13 @@ class ArmigerDHTRSIEngine:
         dp_sigma: float = 0.05,
         max_seen_delta_digests: int = 4096,
         max_tracked_senders: int = 1024,
+        max_sender_tombstones: Optional[int] = None,
         delta_freshness_window_seconds: int = 14 * 86400,
         max_telemetry_queue_size: int = 1024,
         max_item_encryption_retries: int = 3,
+        trusted_evaluator_signers: Optional[Dict[str, str]] = None,
+        trusted_contributor_signers: Optional[Dict[str, str]] = None,
+        require_acyclic_envelope: bool = True,
     ) -> None:
         self.opt_in_sharing: bool = resolve_opt_in_sharing(opt_in_sharing)
         if mode is None:
@@ -151,9 +160,13 @@ class ArmigerDHTRSIEngine:
 
         self.mode = DHTRSIMode(resolved_mode)
         self.current_seq = int(current_seq)
+        self.current_bundle_sha256: Optional[str] = None
         self._telemetry_seq = int(current_seq)
         self.trusted_signers = trusted_signers or {}
         self.trusted_pq_signers = trusted_pq_signers or {}
+        self.trusted_evaluator_signers = dict(trusted_evaluator_signers or {})
+        self.trusted_contributor_signers = dict(trusted_contributor_signers or {})
+        self.require_acyclic_envelope = bool(require_acyclic_envelope)
         self.require_pq = bool(require_pq)
         self.threshold_m = int(threshold_m)
         self.min_distinct_asns = int(min_distinct_asns)
@@ -169,7 +182,12 @@ class ArmigerDHTRSIEngine:
         self.max_item_encryption_retries = max(int(max_item_encryption_retries), 1)
         self._seen_delta_digests: Dict[str, Tuple[int, Tuple[str, bytes]]] = {}
         self._inbound_sender_seq: Dict[Tuple[str, bytes], Tuple[int, int]] = {}
-        self._evicted_sender_seq_floor: int = int(current_seq)
+        self._evicted_sender_tombstones: Dict[Tuple[str, bytes], Tuple[int, int]] = {}
+        self.max_sender_tombstones: int = (
+            max(int(max_sender_tombstones), 1)
+            if max_sender_tombstones is not None
+            else max(self.max_tracked_senders * 8, 256)
+        )
 
         self.verifier = PhysicalGroundTruthVerifier()
         self.anonymizer = TelemetryAnonymizer(
@@ -188,6 +206,8 @@ class ArmigerDHTRSIEngine:
         self._outbound_bundles_shared: int = 0
         self._outbound_packets_blocked_opt_out: int = 0
         self._outbound_bytes_shared: int = 0
+        self._outbound_udp_packets_sent: int = 0
+        self._outbound_udp_puts_succeeded: int = 0
         self._telemetry_encryption_errors: int = 0
         self._telemetry_dropped_backlog: int = 0
         self._last_telemetry_error: str = ""
@@ -259,6 +279,8 @@ class ArmigerDHTRSIEngine:
             "outbound_bundles_shared": int(self._outbound_bundles_shared),
             "outbound_packets_blocked_opt_out": int(self._outbound_packets_blocked_opt_out),
             "outbound_bytes_shared": int(self._outbound_bytes_shared),
+            "outbound_udp_packets_sent": int(getattr(self, "_outbound_udp_packets_sent", 0)),
+            "outbound_udp_puts_succeeded": int(getattr(self, "_outbound_udp_puts_succeeded", 0)),
             "ephemeral_identity_enabled": bool(self.anonymity_guard.ephemeral_identity),
             "ephemeral_pubkey_hex": self.anonymity_guard.current_pubkey_hex() if self.opt_in_sharing else None,
             "ephemeral_rotations": int(self.anonymity_guard.rotation_count),
@@ -371,28 +393,82 @@ class ArmigerDHTRSIEngine:
         for sk in expired_senders:
             self._inbound_sender_seq.pop(sk, None)
 
+        expired_tombstones = [
+            sk for sk, (_, seen_ts) in self._evicted_sender_tombstones.items() if seen_ts < cutoff
+        ]
+        for sk in expired_tombstones:
+            self._evicted_sender_tombstones.pop(sk, None)
+
     def ingest_signed_delta_bundle(
         self,
         signed_bundle: Mapping[str, Any],
+        *,
+        commit: bool = True,
     ) -> Tuple[bool, str, Optional[Dict[str, Any]]]:
         """Verify Ed25519 signature and AnonymityGuard schema of an inbound delta bundle (works in pull_only mode)."""
         if self.mode == DHTRSIMode.OFF:
             return False, "plugin_mode_off", None
 
+        if not isinstance(signed_bundle, Mapping):
+            return False, "malformed_bundle_envelope:not_mapping", None
+
         try:
             v_raw = signed_bundle["v"]
-            v_bytes = v_raw if isinstance(v_raw, (bytes, bytearray)) else str(v_raw).encode("utf-8")
-            seq = int(signed_bundle["seq"])
+            if isinstance(v_raw, str):
+                if len(v_raw) > 2 * 1024 * 1024:
+                    return False, "malformed_bundle_envelope:v_too_large", None
+                v_bytes = v_raw.encode("utf-8")
+            elif isinstance(v_raw, (bytes, bytearray, memoryview)):
+                if len(v_raw) > 2 * 1024 * 1024:
+                    return False, "malformed_bundle_envelope:v_too_large", None
+                v_bytes = bytes(v_raw)
+            else:
+                return False, f"malformed_bundle_envelope:invalid_v_type:{type(v_raw).__name__}", None
+
+            raw_seq = signed_bundle["seq"]
+            if isinstance(raw_seq, bool) or not isinstance(raw_seq, int) or raw_seq < 1 or raw_seq > (2**63 - 1):
+                return False, f"malformed_bundle_envelope:invalid_seq:{raw_seq!r}", None
+            seq = int(raw_seq)
+
             salt = signed_bundle.get("salt", b"armiger-rsi-delta")
+            if salt is None:
+                salt = b"armiger-rsi-delta"
             if isinstance(salt, str):
-                salt = salt.encode("utf-8")
-            salt_bytes = bytes(salt)
+                if len(salt) > 256:
+                    return False, f"bep44_salt_exceeds_64_bytes:{len(salt)}", None
+                salt_bytes = salt.encode("utf-8")
+            elif isinstance(salt, (bytes, bytearray, memoryview)):
+                if len(salt) > 64:
+                    return False, f"bep44_salt_exceeds_64_bytes:{len(salt)}", None
+                salt_bytes = bytes(salt)
+            else:
+                return False, f"malformed_bundle_envelope:invalid_salt_type:{type(salt).__name__}", None
             if len(salt_bytes) > 64:
                 return False, f"bep44_salt_exceeds_64_bytes:{len(salt_bytes)}", None
-            pub_raw = signed_bundle.get("k") or signed_bundle.get("pubkey_hex")
-            pub_bytes = bytes.fromhex(pub_raw) if isinstance(pub_raw, str) else bytes(pub_raw)
-            sig_raw = signed_bundle.get("sig") or signed_bundle.get("sig_hex")
-            sig_bytes = bytes.fromhex(sig_raw) if isinstance(sig_raw, str) else bytes(sig_raw)
+
+            pub_raw = signed_bundle["k"] if signed_bundle.get("k") is not None else signed_bundle.get("pubkey_hex")
+            if isinstance(pub_raw, str):
+                if len(pub_raw.strip()) != 64:
+                    return False, "malformed_bundle_envelope:invalid_pubkey_hex_length", None
+                pub_bytes = bytes.fromhex(pub_raw.strip())
+            elif isinstance(pub_raw, (bytes, bytearray, memoryview)):
+                if len(pub_raw) != 32:
+                    return False, f"malformed_bundle_envelope:invalid_pubkey_length:{len(pub_raw)}", None
+                pub_bytes = bytes(pub_raw)
+            else:
+                return False, f"malformed_bundle_envelope:invalid_pubkey_type:{type(pub_raw).__name__}", None
+
+            sig_raw = signed_bundle["sig"] if signed_bundle.get("sig") is not None else signed_bundle.get("sig_hex")
+            if isinstance(sig_raw, str):
+                if len(sig_raw.strip()) != 128:
+                    return False, "malformed_bundle_envelope:invalid_sig_hex_length", None
+                sig_bytes = bytes.fromhex(sig_raw.strip())
+            elif isinstance(sig_raw, (bytes, bytearray, memoryview)):
+                if len(sig_raw) != 64:
+                    return False, f"malformed_bundle_envelope:invalid_sig_length:{len(sig_raw)}", None
+                sig_bytes = bytes(sig_raw)
+            else:
+                return False, f"malformed_bundle_envelope:invalid_sig_type:{type(sig_raw).__name__}", None
         except Exception as exc:
             return False, f"malformed_bundle_envelope:{exc}", None
 
@@ -406,10 +482,10 @@ class ArmigerDHTRSIEngine:
         self._prune_inbound_delta_tracking(now_ts)
 
         sender_key = (pub_bytes.hex(), salt_bytes)
-        prev_entry = self._inbound_sender_seq.get(sender_key)
+        prev_entry = self._inbound_sender_seq.get(sender_key) or self._evicted_sender_tombstones.get(sender_key)
         min_seq = max(
             self.current_seq,
-            prev_entry[0] if prev_entry is not None else self._evicted_sender_seq_floor,
+            prev_entry[0] if prev_entry is not None else 0,
         )
         if seq <= min_seq:
             return False, f"stale_or_replayed_delta_seq:{seq}<={min_seq}", None
@@ -427,25 +503,33 @@ class ArmigerDHTRSIEngine:
         if epoch_val <= 0 or abs(now_ts - epoch_val) > self.delta_freshness_window_seconds:
             return False, f"stale_or_future_delta_epoch:{epoch_val}", None
 
-        # Any prior digest for this same sender_key is now superseded by the higher monotonic seq
+        # Never evict an unexpired sender high-water mark: if tracking capacity (active + tombstones)
+        # is full of unexpired senders, reject previously unseen sender identities fail-closed.
+        is_known_sender = sender_key in self._inbound_sender_seq or sender_key in self._evicted_sender_tombstones
+        if (
+            not is_known_sender
+            and len(self._inbound_sender_seq) >= self.max_tracked_senders
+            and len(self._evicted_sender_tombstones) >= self.max_sender_tombstones
+        ):
+            return False, "replay_tracking_capacity_exhausted", None
+
         superseded_digests = [
             d for d, (_, sk) in self._seen_delta_digests.items() if sk == sender_key
         ]
-        for d in superseded_digests:
-            self._seen_delta_digests.pop(d, None)
-
-        while len(self._seen_delta_digests) >= self.max_seen_delta_digests:
-            oldest_d = next(iter(self._seen_delta_digests))
-            self._seen_delta_digests.pop(oldest_d, None)
-        self._seen_delta_digests[bundle_digest] = (now_ts, sender_key)
+        projected_digest_count = len(self._seen_delta_digests) - len(superseded_digests)
+        if projected_digest_count >= self.max_seen_delta_digests:
+            evictable_d = next(
+                (
+                    d
+                    for d, (_, sk) in self._seen_delta_digests.items()
+                    if d not in superseded_digests
+                    and (sk in self._inbound_sender_seq or sk in self._evicted_sender_tombstones or sk == sender_key)
+                ),
+                None,
+            )
+            if evictable_d is None:
+                return False, "replay_digest_capacity_exhausted", None
 
-        if sender_key in self._inbound_sender_seq:
-            self._inbound_sender_seq.pop(sender_key, None)
-        while len(self._inbound_sender_seq) >= self.max_tracked_senders:
-            oldest_sk = next(iter(self._inbound_sender_seq))
-            evicted_seq, _ = self._inbound_sender_seq.pop(oldest_sk)
-            self._evicted_sender_seq_floor = max(self._evicted_sender_seq_floor, evicted_seq)
-        self._inbound_sender_seq[sender_key] = (seq, now_ts)
         scale = float(parsed.get("scale", 1.0 / 127.0))
         w_q8 = parsed.get("delta_w_q8", [])
         b_q8 = parsed.get("delta_b_q8", [])
@@ -459,14 +543,48 @@ class ArmigerDHTRSIEngine:
             "reliability_bins": parsed.get("reliability_bins", []),
             "sender_ephemeral_pubkey_hex": pub_bytes.hex(),
         }
+        if not commit:
+            return True, "verified_candidate", decoded
+
+        for d in superseded_digests:
+            self._seen_delta_digests.pop(d, None)
+
+        while len(self._seen_delta_digests) >= self.max_seen_delta_digests:
+            evictable_d = next(
+                (
+                    d
+                    for d, (_, sk) in self._seen_delta_digests.items()
+                    if sk in self._inbound_sender_seq or sk in self._evicted_sender_tombstones or sk == sender_key
+                ),
+                None,
+            )
+            if evictable_d is None:
+                return False, "replay_digest_capacity_exhausted", None
+            self._seen_delta_digests.pop(evictable_d, None)
+
+        eff_retention_ts = max(now_ts, epoch_val)
+        self._seen_delta_digests[bundle_digest] = (eff_retention_ts, sender_key)
+
+        self._evicted_sender_tombstones.pop(sender_key, None)
+        if sender_key in self._inbound_sender_seq:
+            self._inbound_sender_seq.pop(sender_key, None)
+        while len(self._inbound_sender_seq) >= self.max_tracked_senders:
+            if len(self._evicted_sender_tombstones) >= self.max_sender_tombstones:
+                return False, "replay_tracking_capacity_exhausted", None
+            oldest_sk = next(iter(self._inbound_sender_seq))
+            evicted_seq, evicted_ts = self._inbound_sender_seq.pop(oldest_sk)
+            self._evicted_sender_tombstones[oldest_sk] = (evicted_seq, evicted_ts)
+        self._inbound_sender_seq[sender_key] = (seq, eff_retention_ts)
         return True, "verified_and_ingested", decoded
 
     def ingest_signed_bundle(
         self,
         signed_bundle: Mapping[str, Any],
+        *,
+        commit: bool = True,
     ) -> Tuple[bool, str, Optional[Dict[str, Any]]]:
         """Alias for `ingest_signed_delta_bundle`."""
-        return self.ingest_signed_delta_bundle(signed_bundle)
+        return self.ingest_signed_delta_bundle(signed_bundle, commit=commit)
 
     async def publish_to_dht(
         self,
@@ -608,6 +726,14 @@ class ArmigerDHTRSIEngine:
         require_pq: Optional[bool] = None,
         require_authoritative_asn: Optional[bool] = None,
         asn_verifier: Optional[AuthoritativeASNVerifier] = None,
+        bootstrap_checkpoint_seq: Optional[int] = None,
+        authenticated_baseline: Optional[AuthenticatedConformalBaseline] = None,
+        expected_parent_bundle_sha256: Optional[str] = None,
+        expected_canary_suite_sha256: Optional[str] = None,
+        release_envelope: Optional[AcyclicReleaseEnvelope] = None,
+        trusted_evaluator_signers: Optional[Dict[str, str]] = None,
+        trusted_contributor_signers: Optional[Dict[str, str]] = None,
+        require_acyclic_envelope: Optional[bool] = None,
     ) -> Tuple[bool, str, Optional[CanaryRegressionReport]]:
         """Verify signed DHT update manifest, check ASN quorum, validate safe formats, and run 500-canary gate."""
         if self.mode == DHTRSIMode.OFF:
@@ -624,6 +750,27 @@ class ArmigerDHTRSIEngine:
                 for wots_pk_hex in WOTSPlusSHAKE256._ED25519_TO_WOTS_PUBS.get(norm_ed, ()):
                     eff_pq_signers[wots_pk_hex] = identity
         require_pq_flag = self.require_pq if require_pq is None else bool(require_pq)
+        q_ok, q_reason, asns = SybilQuorumVerifier.verify_quorum(
+            attestations=attestations,
+            target_hash=manifest.bundle_sha256,
+            min_distinct_asns=max(self.min_distinct_asns, manifest.min_asn_quorum),
+            asn_verifier=asn_verifier,
+            require_authoritative_asn=require_authoritative_asn,
+        )
+        if authenticated_baseline is not None:
+            b_ok, b_reason = authenticated_baseline.verify_signature(self.trusted_signers)
+            if not b_ok:
+                return False, f"authenticated_baseline_failed:{b_reason}", None
+            eff_parent_sha = (expected_parent_bundle_sha256 or self.current_bundle_sha256 or "").strip().lower()
+            if not eff_parent_sha:
+                return False, "authenticated_baseline_missing_expected_parent_bundle_sha256", None
+            if authenticated_baseline.parent_bundle_sha256.strip().lower() != eff_parent_sha:
+                return False, "authenticated_baseline_parent_bundle_mismatch", None
+            eff_suite_sha = (expected_canary_suite_sha256 or self.canary_gate.suite_sha256()).strip().lower()
+            if authenticated_baseline.canary_suite_sha256.strip().lower() != eff_suite_sha:
+                return False, "authenticated_baseline_canary_suite_mismatch", None
+            baseline_metrics = authenticated_baseline.to_metrics_dict()
+
         ok, reason = ThresholdSignatureVerifier.verify(
             manifest=manifest,
             trusted_signers=self.trusted_signers,
@@ -631,6 +778,9 @@ class ArmigerDHTRSIEngine:
             current_seq=self.current_seq,
             trusted_pq_signers=eff_pq_signers,
             require_pq=require_pq_flag,
+            asn_verifier=asn_verifier,
+            verified_asn_quorum=asns if q_ok else None,
+            bootstrap_checkpoint_seq=bootstrap_checkpoint_seq,
         )
         if not ok:
             return False, f"manifest_threshold_failed:{reason}", None
@@ -640,14 +790,58 @@ class ArmigerDHTRSIEngine:
         if actual_sha.lower() != manifest.bundle_sha256.lower():
             return False, "bundle_sha256_digest_mismatch", None
 
-        # 3. Verify K-of-N distinct-ASN Sybil quorum
-        q_ok, q_reason, asns = SybilQuorumVerifier.verify_quorum(
-            attestations=attestations,
-            target_hash=manifest.bundle_sha256,
-            min_distinct_asns=max(self.min_distinct_asns, manifest.min_asn_quorum),
-            asn_verifier=asn_verifier,
-            require_authoritative_asn=require_authoritative_asn,
+        # 2b. Enforce acyclic provenance envelope (disjoint contributors / evaluators / release signers)
+        eff_req_env = (
+            self.require_acyclic_envelope
+            if require_acyclic_envelope is None
+            else bool(require_acyclic_envelope)
         )
+        if eff_req_env or release_envelope is not None:
+            if release_envelope is None:
+                return False, "missing_acyclic_release_envelope", None
+            if (
+                release_envelope.manifest.canonical_payload() != manifest.canonical_payload()
+                or dict(release_envelope.manifest.signatures) != dict(manifest.signatures)
+                or dict(release_envelope.manifest.pq_signatures) != dict(manifest.pq_signatures)
+            ):
+                return False, "release_envelope_manifest_mismatch", None
+            eff_parent_sha = (expected_parent_bundle_sha256 or self.current_bundle_sha256 or "").strip().lower()
+            if not eff_parent_sha:
+                return False, "release_envelope_missing_expected_parent_bundle_sha256", None
+            if release_envelope.parent_bundle_sha256.strip().lower() != eff_parent_sha:
+                return False, "release_envelope_parent_bundle_mismatch", None
+            eff_suite_sha = (expected_canary_suite_sha256 or self.canary_gate.suite_sha256()).strip().lower()
+            if release_envelope.canary_suite_sha256.strip().lower() != eff_suite_sha:
+                return False, "release_envelope_canary_suite_mismatch", None
+            eff_eval_signers = (
+                dict(trusted_evaluator_signers)
+                if trusted_evaluator_signers is not None
+                else dict(self.trusted_evaluator_signers)
+            )
+            eff_contrib_signers = (
+                dict(trusted_contributor_signers)
+                if trusted_contributor_signers is not None
+                else dict(self.trusted_contributor_signers)
+            )
+            env_ok, env_reason = AcyclicProvenanceVerifier.verify_envelope(
+                release_envelope,
+                trusted_release_signers=self.trusted_signers,
+                trusted_evaluator_signers=eff_eval_signers,
+                threshold_m=self.threshold_m,
+                min_evaluator_asns=max(self.min_distinct_asns, manifest.min_asn_quorum),
+                current_seq=self.current_seq,
+                bootstrap_checkpoint_seq=bootstrap_checkpoint_seq,
+                require_pq=require_pq_flag,
+                asn_verifier=asn_verifier,
+                trusted_release_pq_signers=eff_pq_signers,
+                trusted_contributor_signers=eff_contrib_signers,
+            )
+            if not env_ok:
+                return False, f"acyclic_provenance_failed:{env_reason}", None
+            if authenticated_baseline is None and release_envelope.authenticated_baseline is not None:
+                baseline_metrics = release_envelope.authenticated_baseline.to_metrics_dict()
+
+        # 3. Verify K-of-N distinct-ASN Sybil quorum
         if not q_ok:
             return False, f"sybil_quorum_failed:{q_reason}", None
 
@@ -664,6 +858,280 @@ class ArmigerDHTRSIEngine:
         if not canary_report.passed:
             return False, f"golden_canary_gate_rejected:{canary_report.reason}", canary_report
 
-        # All checks passed! Advance monotonic sequence
+        # All checks passed! Advance monotonic sequence and active bundle digest
         self.current_seq = manifest.seq
+        self.current_bundle_sha256 = actual_sha.lower()
         return True, "update_staged_and_verified", canary_report
+
+    def dispatch_contribution_udp(
+        self,
+        signed_bundle: Optional[Mapping[str, Any]] = None,
+        *,
+        delta_w: Optional[Sequence[float]] = None,
+        delta_b: Optional[Sequence[float]] = None,
+        reliability_bins: Optional[Sequence[Any]] = None,
+        n_samples: int = 25,
+        epoch: Optional[Union[int, float]] = None,
+        seq: Optional[int] = None,
+        model_tier: str = "ultra",
+        salt: bytes = b"armiger-rsi-delta",
+        rotate_key: Optional[bool] = None,
+        dht_nodes: Optional[Sequence[Tuple[str, int]]] = None,
+        collector_nodes: Optional[Sequence[Tuple[str, int]]] = None,
+        discover_collectors: bool = True,
+        release_pubkey_hex: Optional[str] = None,
+        release_salt: Union[bytes, str, None] = None,
+        timeout: float = 2.5,
+        max_dht_puts: int = 8,
+    ) -> Dict[str, Any]:
+        """Publish a signed `< 1,000`-byte BEP-44 delta item over outbound UDP to Mainline DHT
+        (`target = SHA-1(ephemeral_pubkey || "armiger-rsi-delta")`) and directly to collector
+        DHT nodes (`:6881/udp`) discovered via the release pointer.
+
+        Strictly sends 0 packets and opens 0 sockets when `opt_in_sharing=False`.
+        """
+        if not self.opt_in_sharing or self.mode != DHTRSIMode.ANONYMOUS_CONTRIBUTE:
+            self._outbound_packets_blocked_opt_out += 1
+            return {
+                "dispatched": False,
+                "reason": "opt_in_sharing_disabled",
+                "packets_sent": 0,
+                "mainline_puts_ok": 0,
+                "collector_puts_ok": 0,
+            }
+
+        if signed_bundle is None:
+            bundle = self.export_signed_delta_bundle(
+                delta_w=delta_w,
+                delta_b=delta_b,
+                reliability_bins=reliability_bins,
+                n_samples=n_samples,
+                epoch=epoch,
+                seq=seq,
+                model_tier=model_tier,
+                salt=salt,
+                rotate_key=rotate_key,
+            )
+            if bundle is None:
+                return {
+                    "dispatched": False,
+                    "reason": "opt_in_sharing_disabled",
+                    "packets_sent": 0,
+                    "mainline_puts_ok": 0,
+                    "collector_puts_ok": 0,
+                }
+        else:
+            bundle = dict(signed_bundle)
+
+        v_raw = bundle["v"]
+        v_bytes = v_raw.encode("utf-8") if isinstance(v_raw, str) else bytes(v_raw)
+        seq_int = int(bundle["seq"])
+        salt_raw = bundle.get("salt", b"armiger-rsi-delta")
+        salt_bytes = salt_raw.encode("utf-8") if isinstance(salt_raw, str) else bytes(salt_raw)
+        k_raw = bundle.get("k") if bundle.get("k") is not None else bundle.get("pubkey_hex")
+        pub_bytes = bytes.fromhex(k_raw.strip()) if isinstance(k_raw, str) else bytes(k_raw)
+        sig_raw = bundle.get("sig") if bundle.get("sig") is not None else bundle.get("sig_hex")
+        sig_bytes = bytes.fromhex(sig_raw.strip()) if isinstance(sig_raw, str) else bytes(sig_raw)
+
+        # Pre-transmission Canary Firewall & Ed25519 signature verification
+        self.anonymity_guard.inspect_wire_payload(v_bytes)
+        if len(v_bytes) > 1000:
+            raise AnonymityViolationError(f"bep44_value_exceeds_1000_bytes:{len(v_bytes)}")
+        vk = ed25519.Ed25519PublicKey.from_public_bytes(pub_bytes)
+        vk.verify(sig_bytes, _bep44_canonical_sign_buffer(v=v_bytes, seq=seq_int, salt=salt_bytes))
+
+        import socket as _socket
+        try:
+            from verify_dht import (
+                DEFAULT_RELEASE_PUBKEY_HEX,
+                DEFAULT_RELEASE_SALT,
+                _decode_compact_nodes_with_id,
+                _xor_distance,
+                bdecode_krpc,
+                bencode,
+                generate_bep42_node_id,
+                parse_bootstrap_nodes,
+                verify_dht_release,
+            )
+        except ImportError:
+            from verify_dht import (
+                DEFAULT_RELEASE_PUBKEY_HEX,
+                DEFAULT_RELEASE_SALT,
+                _decode_compact_nodes_with_id,
+                _xor_distance,
+                bdecode_krpc,
+                bencode,
+                generate_bep42_node_id,
+                parse_bootstrap_nodes,
+                verify_dht_release,
+            )
+
+        target_20 = hashlib.sha1(pub_bytes + salt_bytes).digest()
+        eff_dht_nodes: List[Tuple[str, int]] = (
+            list(dht_nodes) if dht_nodes is not None else parse_bootstrap_nodes()
+        )
+        eff_collectors: List[Tuple[str, int]] = list(collector_nodes or ())
+        env_collectors = os.environ.get("ARMIGER_DHT_COLLECTOR_NODES", "").strip()
+        if env_collectors:
+            for c_addr in parse_bootstrap_nodes(env_collectors):
+                if c_addr not in eff_collectors:
+                    eff_collectors.append(c_addr)
+
+        if discover_collectors and eff_dht_nodes:
+            try:
+                ptr_rec = verify_dht_release(
+                    pubkey_hex=release_pubkey_hex or DEFAULT_RELEASE_PUBKEY_HEX,
+                    salt=release_salt or DEFAULT_RELEASE_SALT,
+                    dht_nodes=eff_dht_nodes,
+                    pointer_only=True,
+                    timeout=timeout,
+                    max_dht_queries=16,
+                )
+                for c_item in ptr_rec.get("collector_nodes", []) or []:
+                    if isinstance(c_item, (list, tuple)) and len(c_item) == 2:
+                        c_tup = (str(c_item[0]), int(c_item[1]))
+                        if c_tup not in eff_collectors:
+                            eff_collectors.append(c_tup)
+            except Exception:
+                pass
+
+        packets_sent = 0
+        mainline_puts_ok = 0
+        collector_puts_ok = 0
+        errors: List[str] = []
+        put_attempted_addrs: Set[Tuple[str, int]] = set()
+
+        def _single_socket_get_and_put(addr: Tuple[str, int]) -> Tuple[bool, List[Tuple[bytes, Tuple[str, int]]]]:
+            nonlocal packets_sent
+            host_str, port_int = str(addr[0]).strip(), int(addr[1])
+            try:
+                resolved_ip = _socket.gethostbyname(host_str)
+            except Exception as exc:
+                errors.append(f"{host_str}:{port_int}:resolve:{exc}")
+                return False, []
+            norm_addr = (resolved_ip, port_int)
+            if norm_addr in put_attempted_addrs:
+                return False, []
+            sock = _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM)
+            refs: List[Tuple[bytes, Tuple[str, int]]] = []
+            try:
+                sock.settimeout(max(0.2, float(timeout)))
+                sock.connect(norm_addr)
+                local_ip = str(sock.getsockname()[0]) or "127.0.0.1"
+                node_id = generate_bep42_node_id(local_ip)
+                q_get = {
+                    b"t": b"cg01",
+                    b"y": b"q",
+                    b"q": b"get",
+                    b"a": {b"id": node_id, b"target": target_20},
+                }
+                sock.send(bencode(q_get))
+                packets_sent += 1
+                self._outbound_udp_packets_sent += 1
+                raw_get = sock.recv(8192)
+                msg_get = bdecode_krpc(raw_get)
+                if not isinstance(msg_get, dict) or msg_get.get(b"y") != b"r":
+                    return False, refs
+                r_body = msg_get.get(b"r")
+                if not isinstance(r_body, dict):
+                    return False, refs
+                refs.extend(_decode_compact_nodes_with_id(r_body.get(b"nodes"), None))
+                for entry in r_body.get(b"nodes_list", []) or []:
+                    if (
+                        isinstance(entry, list)
+                        and len(entry) == 3
+                        and isinstance(entry[0], (bytes, bytearray))
+                        and len(entry[0]) == 20
+                        and isinstance(entry[1], (bytes, bytearray))
+                    ):
+                        refs.append((bytes(entry[0]), ( bytes(entry[1]).decode("ascii", errors="ignore"), int(entry[2]) )))
+                tok = r_body.get(b"token")
+                if not isinstance(tok, (bytes, bytearray)) or not tok:
+                    return False, refs
+                put_attempted_addrs.add(norm_addr)
+                q_put = {
+                    b"t": b"cp01",
+                    b"y": b"q",
+                    b"q": b"put",
+                    b"a": {
+                        b"id": node_id,
+                        b"k": pub_bytes,
+                        b"salt": salt_bytes,
+                        b"seq": int(seq_int),
+                        b"sig": sig_bytes,
+                        b"token": bytes(tok),
+                        b"v": v_bytes,
+                    },
+                }
+                sock.send(bencode(q_put))
+                packets_sent += 1
+                self._outbound_udp_packets_sent += 1
+                raw_put = sock.recv(8192)
+                msg_put = bdecode_krpc(raw_put)
+                if isinstance(msg_put, dict) and msg_put.get(b"y") == b"r":
+                    self._outbound_udp_puts_succeeded += 1
+                    return True, refs
+                err_val = msg_put.get(b"e_detail") or msg_put.get(b"e") if isinstance(msg_put, dict) else "invalid_resp"
+                errors.append(f"{resolved_ip}:{port_int}:put_rejected:{err_val}")
+                return False, refs
+            except Exception as exc:
+                errors.append(f"{resolved_ip}:{port_int}:{exc}")
+                return False, refs
+            finally:
+                sock.close()
+
+        resolved_collector_set: Set[Tuple[str, int]] = set()
+        for c_host, c_port in eff_collectors:
+            try:
+                c_ip = _socket.gethostbyname(str(c_host).strip())
+                resolved_collector_set.add((c_ip, int(c_port)))
+            except Exception:
+                continue
+
+        # 1. Direct BEP-44 put to discovered/configured collector DHT nodes (:6881/udp)
+        for c_addr in eff_collectors:
+            ok_put, _ = _single_socket_get_and_put(c_addr)
+            if ok_put:
+                collector_puts_ok += 1
+
+        # 2. Iterative BEP-44 lookup + put to Mainline DHT nodes
+        frontier: List[Tuple[int, Tuple[str, int]]] = [
+            (_xor_distance(None, target_20), n_addr) for n_addr in eff_dht_nodes
+        ]
+        visited_walk: Set[Tuple[str, int]] = set()
+        while frontier and len(visited_walk) < 16 and mainline_puts_ok < max_dht_puts:
+            frontier.sort(key=lambda item: item[0])
+            _, cur_addr = frontier.pop(0)
+            try:
+                cur_ip = _socket.gethostbyname(str(cur_addr[0]).strip())
+                norm_cur = (cur_ip, int(cur_addr[1]))
+            except Exception:
+                continue
+            if norm_cur in visited_walk:
+                continue
+            visited_walk.add(norm_cur)
+            if norm_cur in put_attempted_addrs:
+                if norm_cur in resolved_collector_set and collector_puts_ok > 0:
+                    mainline_puts_ok += 1
+                continue
+            ok_put, refs = _single_socket_get_and_put(norm_cur)
+            if ok_put:
+                mainline_puts_ok += 1
+                if norm_cur in resolved_collector_set:
+                    collector_puts_ok += 1
+            for ref_nid, ref_addr in refs:
+                if ref_addr not in visited_walk:
+                    frontier.append((_xor_distance(ref_nid, target_20), ref_addr))
+
+        return {
+            "dispatched": (mainline_puts_ok + collector_puts_ok) > 0,
+            "target_hex": target_20.hex(),
+            "pubkey_hex": pub_bytes.hex(),
+            "seq": seq_int,
+            "payload_bytes": len(v_bytes),
+            "packets_sent": packets_sent,
+            "mainline_puts_ok": mainline_puts_ok,
+            "collector_puts_ok": collector_puts_ok,
+            "collector_nodes": [list(c) for c in eff_collectors],
+            "errors": errors,
+        }

armiger_inference.py

@@ -130,7 +130,7 @@ def _extract_token_hashes(text: str) -> frozenset[str]:
 
 def _get_vocab_ext_map(vocab_path: Optional[Path] = None) -> Dict[str, int]:
     global _VOCAB_EXT_MAP
-    if _VOCAB_EXT_MAP is not None and len(_VOCAB_EXT_MAP) > 64:
+    if vocab_path is None and _VOCAB_EXT_MAP is not None and len(_VOCAB_EXT_MAP) > 64:
         return _VOCAB_EXT_MAP
     vpath = vocab_path if (vocab_path and vocab_path.exists()) else Path(__file__).resolve().with_name("vocab.json")
     if not vpath.exists() and os.environ.get("ARMIGER_MODEL_DIR"):
@@ -469,7 +469,11 @@ class ArmigerStandaloneONNX:
     ) -> None:
         import onnxruntime as ort
 
-        base = Path(__file__).resolve().parent
+        try:
+            from artifacts import model_directory
+            base = model_directory()
+        except ImportError:
+            base = Path(__file__).resolve().parent
         if onnx_path is None:
             for cand in ("armiger.onnx", "armiger.int8.onnx", "armiger_ultra.fp32.onnx"):
                 if (base / cand).exists():
@@ -485,14 +489,28 @@ class ArmigerStandaloneONNX:
         _get_vocab_ext_map(self.vocab_path)
         self.calibration_path = Path(calibration_path) if calibration_path else (base / "calibration.json")
         self.session = ort.InferenceSession(str(self.onnx_path), providers=["CPUExecutionProvider"])
-        self.head_names = [o.name for o in self.session.get_outputs()]
+        self.head_names = [o.name for o in self.session.get_outputs() if o.name != "bio64"]
+        self._batch_fn = build_onnx_batch_inputs
+        try:
+            for inp in self.session.get_inputs():
+                if getattr(inp, "name", "") == "stats":
+                    sh = getattr(inp, "shape", None)
+                    if isinstance(sh, (list, tuple)) and len(sh) >= 2 and type(sh[1]) is int and sh[1] == 41:
+                        try:
+                            from r13_features import build_onnx_batch_inputs as _r13_batch_fn
+                        except ImportError:
+                            from r13_features import build_onnx_batch_inputs as _r13_batch_fn  # type: ignore
+                        self._batch_fn = _r13_batch_fn
+                        break
+        except Exception:
+            pass
 
     @staticmethod
     def _apply_v3_post_neural_guard(row: Mapping[str, Any], item_res: Dict[str, Any]) -> Dict[str, Any]:
         return _apply_v3_post_neural_guard(row, item_res)
 
     def predict_batch(self, rows: Sequence[Mapping[str, Any]]) -> List[Dict[str, Any]]:
-        feed = build_onnx_batch_inputs(rows)
+        feed = self._batch_fn(rows)
         raw_outs = self.session.run(self.head_names, feed)
         logits_by_head = dict(zip(self.head_names, raw_outs))
         results: List[Dict[str, Any]] = []
@@ -507,9 +525,9 @@ class ArmigerStandaloneONNX:
                     probs_2d = exps / np.maximum(1e-12, np.sum(exps, axis=-1, keepdims=True))
                     raw_nm = str(rows[i].get("name") or rows[i].get("title") or "")
                     try:
-                        from armiger.byte_span_extractor import decode_bio_logits_viterbi, decode_bio_tags_to_spans
-                    except ImportError:
                         from byte_span_extractor import decode_bio_logits_viterbi, decode_bio_tags_to_spans
+                    except ImportError:
+                        from byte_span_extractor import decode_bio_logits_viterbi, decode_bio_tags_to_spans  # type: ignore
                     raw_b = raw_nm.encode("utf-8", errors="replace")[: vec.shape[0]]
                     tag_ids = [int(x) for x in decode_bio_logits_viterbi(vec, raw_b).tolist()]
                     classes = NEURAL_HEAD_CLASSES.get(

calibration.json

@@ -1,67 +1,84 @@
 {
-  "temperature_scaling_stop_fit": {
-    "category": {
-      "temperature_T": 0.65,
-      "cal_temp_scaled": {
-        "n": 995,
-        "fitted_on": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41_val_guarded"
-      }
-    },
-    "lang": {
-      "temperature_T": 0.7,
-      "cal_temp_scaled": {
-        "n": 368,
-        "fitted_on": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41_val_guarded"
-      }
+  "calibrated_onnx_fp32_sha256": "6f94aef676e5bec4968378437769cfdc768fefcc6a21854b8319b33456ebd2ec",
+  "calibration_version": "v3.0-gold-r13_3-val-only",
+  "feature_stats_dim": 41,
+  "fitted_snapshot_id": "snap_r13_20261024T140340Z_064c8e6ccb1f",
+  "fp32_vs_int8_val_parity": {
+    "adult": {
+      "fp32_int8_agreement_pct": 100.0,
+      "meets_99_5pct_gate": true
     },
-    "owner_scope": {
-      "temperature_T": 0.55,
-      "cal_temp_scaled": {
-        "n": 995,
-        "fitted_on": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41_val_guarded"
-      }
+    "all_heads_min_agreement_pct": 99.57,
+    "anime": {
+      "bal_acc_drift_pct": 0.11,
+      "fp32_int8_agreement_pct": 99.93,
+      "fp32_val_bal_acc": 77.67,
+      "fp32_val_macro_f1": 75.02,
+      "int8_val_bal_acc": 77.78,
+      "int8_val_macro_f1": 75.18,
+      "meets_99_5pct_gate": true
     },
-    "title_language": {
-      "temperature_T": 0.95,
-      "cal_temp_scaled": {
-        "n": 566,
-        "fitted_on": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41_val_guarded"
-      }
+    "category": {
+      "bal_acc_drift_pct": 0.34,
+      "fp32_int8_agreement_pct": 99.57,
+      "fp32_val_bal_acc": 85.15,
+      "fp32_val_macro_f1": 84.97,
+      "int8_val_bal_acc": 84.81,
+      "int8_val_macro_f1": 84.75,
+      "meets_99_5pct_gate": true
     },
     "english_subs": {
-      "temperature_T": 0.5,
-      "cal_temp_scaled": {
-        "n": 137,
-        "fitted_on": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41_val_guarded"
-      }
+      "bal_acc_drift_pct": 0.0,
+      "fp32_int8_agreement_pct": 99.57,
+      "fp32_val_bal_acc": 97.65,
+      "fp32_val_macro_f1": 97.57,
+      "int8_val_bal_acc": 97.65,
+      "int8_val_macro_f1": 97.57,
+      "meets_99_5pct_gate": true
     },
-    "anime": {
-      "temperature_T": 0.9,
-      "cal_temp_scaled": {
-        "n": 243,
-        "fitted_on": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41_val_guarded"
-      }
+    "junk": {
+      "fp32_int8_agreement_pct": 100.0,
+      "meets_99_5pct_gate": true
     },
-    "adult": {
-      "temperature_T": 0.65,
-      "cal_temp_scaled": {
-        "n": 864,
-        "fitted_on": "snapshot_wave5a_val"
-      }
+    "lang": {
+      "bal_acc_drift_pct": 0.0,
+      "fp32_int8_agreement_pct": 99.79,
+      "fp32_val_bal_acc": 73.68,
+      "fp32_val_macro_f1": 74.78,
+      "int8_val_bal_acc": 73.68,
+      "int8_val_macro_f1": 74.78,
+      "meets_99_5pct_gate": true
     },
-    "junk": {
-      "temperature_T": 0.65,
-      "cal_temp_scaled": {
-        "n": 864,
-        "fitted_on": "snapshot_wave5a_val"
-      }
+    "meets_99_5pct_gate": true,
+    "owner_scope": {
+      "bal_acc_drift_pct": 0.0,
+      "fp32_int8_agreement_pct": 100.0,
+      "fp32_val_bal_acc": 96.32,
+      "fp32_val_macro_f1": 96.32,
+      "int8_val_bal_acc": 96.32,
+      "int8_val_macro_f1": 96.32,
+      "meets_99_5pct_gate": true
+    },
+    "span_bio": {
+      "fp32_int8_agreement_pct": 99.7,
+      "fp32_val_byte_acc": 67.93,
+      "int8_val_byte_acc": 67.95
+    },
+    "title_language": {
+      "bal_acc_drift_pct": 0.0,
+      "fp32_int8_agreement_pct": 99.86,
+      "fp32_val_bal_acc": 83.33,
+      "fp32_val_macro_f1": 89.5,
+      "int8_val_bal_acc": 83.33,
+      "int8_val_macro_f1": 89.5,
+      "meets_99_5pct_gate": true
     }
   },
   "menon_logit_adjustment_stop_fit": {
-    "D80000": {
+    "D100000": {
       "tau": 0.0
     },
-    "D100000": {
+    "D80000": {
       "tau": 0.0
     },
     "E100000_TC_v3": {
@@ -83,106 +100,2676 @@
       "tau": 0.0
     }
   },
+  "mondrian_audit": {
+    "owner_scope": {
+      "alpha": 0.02,
+      "method": "split-conformal FPR quantile ceil((n+1)(1-alpha)) on val negatives, 2-fold temperature-scaled probs",
+      "n_neg": 625,
+      "n_pos": 786,
+      "val_fpr_at_thr": 0.0176,
+      "val_recall_at_thr": 0.975827
+    }
+  },
   "mondrian_conformal_thresholds": {
     "owner_scope": {
       "alpha": 0.02,
-      "threshold_r5clean": 0.52486
+      "threshold": 0.280814
+    }
+  },
+  "mondrian_thresholds": {
+    "owner_scope": 0.280814
+  },
+  "owner_scope_r12": {
+    "counts": {
+      "audiobook": 61,
+      "comic": 149,
+      "course": 22,
+      "ebook": 75,
+      "game": 157,
+      "movie": 377,
+      "music": 184,
+      "software": 118,
+      "tv_show": 267,
+      "unknown": 0,
+      "xxx": 1
+    },
+    "excluded_categories": [
+      "music",
+      "comic",
+      "game",
+      "audiobook",
+      "software",
+      "ebook",
+      "course"
+    ],
+    "feature_stats_dim": 41,
+    "fitting": "two-fold group cross-fit audit; full validation refit",
+    "folds": [
+      {
+        "balanced_error": 0.03196061087255235,
+        "counts": {
+          "audiobook": 32,
+          "comic": 82,
+          "course": 13,
+          "ebook": 41,
+          "game": 79,
+          "movie": 172,
+          "music": 87,
+          "software": 65,
+          "tv_show": 133,
+          "unknown": 0,
+          "xxx": 1
+        },
+        "heldout_fold": 0,
+        "holdout_groups": [
+          "r10-comp-00005",
+          "r10-comp-00049",
+          "r10-comp-00059",
+          "r10-comp-00067",
+          "r10-comp-00084",
+          "r10-comp-00092",
+          "r10-comp-00122",
+          "r10-comp-00176",
+          "r10-comp-00204",
+          "r10-comp-00221",
+          "r10-comp-00236",
+          "r10-comp-00238",
+          "r10-comp-00240",
+          "r10-comp-00269",
+          "r10-comp-00311",
+          "r10-comp-00343",
+          "r10-comp-00371",
+          "r10-comp-00379",
+          "r10-comp-00384",
+          "r10-comp-00393",
+          "r10-comp-00450",
+          "r10-comp-00469",
+          "r10-comp-00542",
+          "r10-comp-00553",
+          "r10-comp-00558",
+          "r10-comp-00560",
+          "r10-comp-00563",
+          "r10-comp-00610",
+          "r10-comp-00614",
+          "r10-comp-00619",
+          "r10-comp-00626",
+          "r10-comp-00646",
+          "r10-comp-00675",
+          "r10-comp-00705",
+          "r10-comp-00732",
+          "r10-comp-00749",
+          "r10-comp-00768",
+          "r10-comp-00769",
+          "r10-comp-00777",
+          "r10-comp-00817",
+          "r10-comp-00848",
+          "r10-comp-00874",
+          "r10-comp-00892",
+          "r10-comp-01011",
+          "r10-comp-01014",
+          "r10-comp-01039",
+          "r10-comp-01047",
+          "r10-comp-01136",
+          "r10-comp-01277",
+          "r10-comp-01309",
+          "r10-comp-01320",
+          "r10-comp-01341",
+          "r10-comp-01353",
+          "r10-comp-01356",
+          "r10-comp-01405",
+          "r10-comp-01441",
+          "r10-comp-01445",
+          "r10-comp-01447",
+          "r10-comp-01485",
+          "r10-comp-01566",
+          "r10-comp-01622",
+          "r10-comp-01626",
+          "r10-comp-01647",
+          "r10-comp-01693",
+          "r10-comp-01725",
+          "r10-comp-01751",
+          "r10-comp-01760",
+          "r10-comp-01795",
+          "r10-comp-01808",
+          "r10-comp-01816",
+          "r10-comp-01826",
+          "r10-comp-01827",
+          "r10-comp-01860",
+          "r10-comp-01893",
+          "r10-comp-01907",
+          "r10-comp-01941",
+          "r10-comp-01972",
+          "r10-comp-01981",
+          "r10-comp-01999",
+          "r10-comp-02018",
+          "r10-comp-02137",
+          "r10-comp-02146",
+          "r10-comp-02206",
+          "r10-comp-02236",
+          "r10-comp-02302",
+          "r10-comp-02305",
+          "r10-comp-02341",
+          "r10-comp-02361",
+          "r10-comp-02373",
+          "r10-comp-02396",
+          "r10-comp-02421",
+          "r10-comp-02448",
+          "r10-comp-02497",
+          "r10-comp-02548",
+          "r10-comp-02553",
+          "r10-comp-02591",
+          "r10-comp-02593",
+          "r10-comp-02600",
+          "r10-comp-02622",
+          "r10-comp-02640",
+          "r10-comp-02654",
+          "r10-comp-02698",
+          "r10-comp-02764",
+          "r10-comp-02824",
+          "r10-comp-02839",
+          "r10-comp-02930",
+          "r10-comp-02983",
+          "r10-comp-02990",
+          "r10-comp-03005",
+          "r10-comp-03040",
+          "r10-comp-03133",
+          "r10-comp-03188",
+          "r10-comp-03229",
+          "r10-comp-03239",
+          "r10-comp-03260",
+          "r10-comp-03265",
+          "r10-comp-03274",
+          "r10-comp-03282",
+          "r10-comp-03298",
+          "r10-comp-03300",
+          "r10-comp-03317",
+          "r10-comp-03384",
+          "r10-comp-03436",
+          "r10-comp-03535",
+          "r10-comp-03565",
+          "r10-comp-03586",
+          "r10-comp-03590",
+          "r10-comp-03597",
+          "r10-comp-03603",
+          "r10-comp-03633",
+          "r10-comp-03648",
+          "r10-comp-03649",
+          "r10-comp-03681",
+          "r10-comp-03711",
+          "r10-comp-03823",
+          "r10-comp-03838",
+          "r10-comp-03846",
+          "r10-comp-03847",
+          "r10-comp-03857",
+          "r10-comp-03859",
+          "r10-comp-03877",
+          "r10-comp-03892",
+          "r10-comp-03894",
+          "r10-comp-03916",
+          "r10-comp-03924",
+          "r10-comp-03942",
+          "r10-comp-03957",
+          "r10-comp-03963",
+          "r10-comp-04000",
+          "r10-comp-04029",
+          "r10-comp-04049",
+          "r10-comp-04114",
+          "r10-comp-04119",
+          "r10-comp-04139",
+          "r10-comp-04197",
+          "r10-comp-04238",
+          "r10-comp-04251",
+          "r10-comp-04270",
+          "r10-comp-04271",
+          "r10-comp-04278",
+          "r10-comp-04286",
+          "r10-comp-04297",
+          "r10-comp-04322",
+          "r10-comp-04340",
+          "r10-comp-04342",
+          "r10-comp-04349",
+          "r10-comp-04365",
+          "r10-comp-04385",
+          "r10-comp-04393",
+          "r10-comp-04438",
+          "r10-comp-04450",
+          "r10-comp-04494",
+          "r10-comp-04505",
+          "r10-comp-04534",
+          "r10-comp-04544",
+          "r10-comp-04555",
+          "r10-comp-04594",
+          "r10-comp-04596",
+          "r10-comp-04605",
+          "r10-comp-04637",
+          "r10-comp-04656",
+          "r10-comp-04657",
+          "r10-comp-04660",
+          "r10-comp-04671",
+          "r10-comp-04701",
+          "r10-comp-04717",
+          "r10-comp-04725",
+          "r10-comp-04740",
+          "r10-comp-04742",
+          "r10-comp-04753",
+          "r10-comp-04755",
+          "r10-comp-04762",
+          "r10-comp-04772",
+          "r10-comp-04776",
+          "r10-comp-04783",
+          "r10-comp-04796",
+          "r10-comp-04812",
+          "r10-comp-04827",
+          "r10-comp-04845",
+          "r10-comp-04871",
+          "r10-comp-04876",
+          "r10-comp-04879",
+          "r10-comp-04887",
+          "r10-comp-04898",
+          "r10-comp-04913",
+          "r10-comp-04919",
+          "r10-comp-04956",
+          "r10-comp-04966",
+          "r10-comp-04986",
+          "r10-comp-04990",
+          "r10-comp-05023",
+          "r10-comp-05027",
+          "r10-comp-05029",
+          "r10-comp-05038",
+          "r10-comp-05061",
+          "r10-comp-05070",
+          "r10-comp-05080",
+          "r10-comp-05081",
+          "r10-comp-05083",
+          "r10-comp-05099",
+          "r10-comp-05106",
+          "r10-comp-05111",
+          "r10-comp-05151",
+          "r10-comp-05157",
+          "r10-comp-05162",
+          "r10-comp-05168",
+          "r10-comp-05178",
+          "r10-comp-05218",
+          "r10-comp-05224",
+          "r10-comp-05234",
+          "r10-comp-05276",
+          "r10-comp-05309",
+          "r10-comp-05310",
+          "r10-comp-05316",
+          "r10-comp-05337",
+          "r10-comp-05349",
+          "r10-comp-05350",
+          "r10-comp-05352",
+          "r10-comp-05356",
+          "r10-comp-05366",
+          "r10-comp-05369",
+          "r10-comp-05370",
+          "r10-comp-05381",
+          "r10-comp-05383",
+          "r10-comp-05384",
+          "r10-comp-05389",
+          "r10-comp-05390",
+          "r10-comp-05427",
+          "r10-comp-05440",
+          "r10-comp-05452",
+          "r10-comp-05465",
+          "r10-comp-05466",
+          "r10-comp-05481",
+          "r10-comp-05486",
+          "r10-comp-05490",
+          "r10-comp-05539",
+          "r10-comp-05542",
+          "r10-comp-05545",
+          "r10-comp-05547",
+          "r10-comp-05553",
+          "r10-comp-05606",
+          "r10-comp-05621",
+          "r10-comp-05630",
+          "r10-comp-05653",
+          "r10-comp-05668",
+          "r10-comp-05682",
+          "r10-comp-05685",
+          "r10-comp-05688",
+          "r10-comp-05691",
+          "r10-comp-05711",
+          "r10-comp-05723",
+          "r10-comp-05725",
+          "r10-comp-05737",
+          "r10-comp-05744",
+          "r10-comp-05751",
+          "r10-comp-05755",
+          "r10-comp-05783",
+          "r10-comp-05789",
+          "r10-comp-05802",
+          "r10-comp-05849",
+          "r10-comp-05877",
+          "r10-comp-05880",
+          "r10-comp-05892",
+          "r10-comp-05908",
+          "r10-comp-05928",
+          "r10-comp-05957",
+          "r10-comp-05958",
+          "r10-comp-05980",
+          "r10-comp-06003",
+          "r10-comp-06019",
+          "r10-comp-06024",
+          "r10-comp-06032",
+          "r10-comp-06051",
+          "r10-comp-06057",
+          "r10-comp-06079",
+          "r10-comp-06089",
+          "r10-comp-06109",
+          "r10-comp-06139",
+          "r10-comp-06140",
+          "r10-comp-06151",
+          "r10-comp-06194",
+          "r10-comp-06196",
+          "r10-comp-06216",
+          "r10-comp-06230",
+          "r10-comp-06231",
+          "r10-comp-06286",
+          "r10-comp-06293",
+          "r10-comp-06306",
+          "r10-comp-06330",
+          "r10-comp-06354",
+          "r10-comp-06366",
+          "r10-comp-06391",
+          "r10-comp-06412",
+          "r10-comp-06415",
+          "r10-comp-06420",
+          "r10-comp-06423",
+          "r10-comp-06451",
+          "r10-comp-06457",
+          "r10-comp-06467",
+          "r10-comp-06498",
+          "r10-comp-06505",
+          "r10-comp-06523",
+          "r10-comp-06524",
+          "r10-comp-06545",
+          "r10-comp-06579",
+          "r10-comp-06590",
+          "r10-comp-06595",
+          "r10-comp-06638",
+          "r10-comp-06654",
+          "r10-comp-06676",
+          "r10-comp-06691",
+          "r10-comp-06702",
+          "r10-comp-06711",
+          "r10-comp-06721",
+          "r10-comp-06744",
+          "r10-comp-06779",
+          "r10-comp-06785",
+          "r10-comp-06802",
+          "r10-comp-06815",
+          "r10-comp-06843",
+          "r10-comp-06863",
+          "r10-comp-06874",
+          "r10-comp-06885",
+          "r10-comp-06886",
+          "r10-comp-06911",
+          "r10-comp-06918",
+          "r10-comp-06927",
+          "r10-comp-06930",
+          "r10-comp-06931",
+          "r10-comp-06943",
+          "r10-comp-06959",
+          "r10-comp-06962",
+          "r10-comp-06971",
+          "r10-comp-06995",
+          "r10-comp-07009",
+          "r10-comp-07010",
+          "r10-comp-07014",
+          "r10-comp-07017",
+          "r10-comp-07018",
+          "r10-comp-07024",
+          "r10-comp-07025",
+          "r10-comp-07037",
+          "r10-comp-07069",
+          "r10-comp-07070",
+          "r10-comp-07076",
+          "r10-comp-07092",
+          "r10-comp-07097",
+          "r10-comp-07105",
+          "r10-comp-07110",
+          "r10-comp-07123",
+          "r10-comp-07127",
+          "r10-comp-07148",
+          "r10-comp-07153",
+          "r10-comp-07196",
+          "r10-comp-07224",
+          "r10-comp-07229",
+          "r10-comp-07239",
+          "r10-comp-07256",
+          "r10-comp-07268",
+          "r10-comp-07271",
+          "r10-comp-07284",
+          "r10-comp-07288",
+          "r10-comp-07293",
+          "r10-comp-07308",
+          "r10-comp-07313",
+          "r10-comp-07334",
+          "r10-comp-07347",
+          "r10-comp-07353",
+          "r10-comp-07365",
+          "r10-comp-07377",
+          "r10-comp-07387",
+          "r10-comp-07391",
+          "r10-comp-07404",
+          "r10-comp-07408",
+          "r10-comp-07410",
+          "r10-comp-07420",
+          "r10-comp-07423",
+          "r10-comp-07435",
+          "r10-comp-07441",
+          "r10-comp-07451",
+          "r10-comp-07453",
+          "r10-comp-07458",
+          "r10-comp-07466",
+          "r10-comp-07475",
+          "r10-comp-07487",
+          "r10-comp-07511",
+          "r10-comp-07517",
+          "r10-comp-07522",
+          "r10-comp-07530",
+          "r10-comp-07531",
+          "r10-comp-07533",
+          "r10-comp-07537",
+          "r10-comp-07539",
+          "r10-comp-07540",
+          "r10-comp-07548",
+          "r10-comp-07579",
+          "r10-comp-07585",
+          "r10-comp-07631",
+          "r10-comp-07641",
+          "r10-comp-07654",
+          "r10-comp-07657",
+          "r10-comp-07658",
+          "r10-comp-07660",
+          "r10-comp-07669",
+          "r10-comp-07674",
+          "r10-comp-07687",
+          "r10-comp-07750",
+          "r10-comp-07755",
+          "r10-comp-07767",
+          "r10-comp-07785",
+          "r10-comp-07786",
+          "r10-comp-07789",
+          "r10-comp-07801",
+          "r10-comp-07819",
+          "r10-comp-07821",
+          "r10-comp-07824",
+          "r10-comp-07827",
+          "r10-comp-07869",
+          "r10-comp-07884",
+          "r10-comp-07886",
+          "r10-comp-07887",
+          "r10-comp-07889",
+          "r10-comp-07895",
+          "r10-comp-07914",
+          "r10-comp-07933",
+          "r10-comp-07944",
+          "r10-comp-07972",
+          "r10-comp-07979",
+          "r10-comp-08007",
+          "r10-comp-08019",
+          "r10-comp-08026",
+          "r10-comp-08042",
+          "r10-comp-08048",
+          "r10-comp-08049",
+          "r10-comp-08050",
+          "r10-comp-08057",
+          "r10-comp-08068",
+          "r10-comp-08069",
+          "r10-comp-08070",
+          "r10-comp-08082",
+          "r10-comp-08087",
+          "r10-comp-08088",
+          "r10-comp-08117",
+          "r10-comp-08124",
+          "r10-comp-08126",
+          "r10-comp-08129",
+          "r10-comp-08132",
+          "r10-comp-08148",
+          "r10-comp-08163",
+          "r10-comp-08171",
+          "r10-comp-08189",
+          "r10-comp-08190",
+          "r10-comp-08196",
+          "r10-comp-08202",
+          "r10-comp-08212",
+          "r10-comp-08248",
+          "r10-comp-08253",
+          "r10-comp-08254",
+          "r10-comp-08257",
+          "r10-comp-08263",
+          "r10-comp-08274",
+          "r10-comp-08293",
+          "r10-comp-08294",
+          "r10-comp-08298",
+          "r10-comp-08301",
+          "r10-comp-08302",
+          "r10-comp-08333",
+          "r10-comp-08337",
+          "r10-comp-08356",
+          "r10-comp-08367",
+          "r10-comp-08378",
+          "r10-comp-08379",
+          "r10-comp-08383",
+          "r10-comp-08400",
+          "r10-comp-08408",
+          "r10-comp-08419",
+          "r10-comp-08433",
+          "r10-comp-08470",
+          "r10-comp-08477",
+          "r10-comp-08490",
+          "r10-comp-08493",
+          "r10-comp-08507",
+          "r10-comp-08515",
+          "r10-comp-08530",
+          "r10-comp-08538",
+          "r10-comp-08539",
+          "r10-comp-08556",
+          "r10-comp-08569",
+          "r10-comp-08590",
+          "r10-comp-08598",
+          "r10-comp-08634",
+          "r10-comp-08657",
+          "r10-comp-08674",
+          "r10-comp-08684",
+          "r10-comp-08686",
+          "r10-comp-08690",
+          "r10-comp-08695",
+          "r10-comp-08702",
+          "r10-comp-08706",
+          "r10-comp-08721",
+          "r10-comp-08742",
+          "r10-comp-08776",
+          "r10-comp-08795",
+          "r10-comp-08803",
+          "r10-comp-08806",
+          "r10-comp-08816",
+          "r10-comp-08817",
+          "r10-comp-08824",
+          "r10-comp-08835",
+          "r10-comp-08841",
+          "r10-comp-08843",
+          "r10-comp-08855",
+          "r10-comp-08870",
+          "r10-comp-08893",
+          "r10-comp-08909",
+          "r10-comp-08926",
+          "r10-comp-08932",
+          "r10-comp-08941",
+          "r10-comp-08946",
+          "r10-comp-08956",
+          "r10-comp-08972",
+          "r10-comp-08985",
+          "r10-comp-09006",
+          "r10-comp-09031",
+          "r10-comp-09041",
+          "r10-comp-09044",
+          "r10-comp-09051",
+          "r10-comp-09063",
+          "r10-comp-09066",
+          "r10-comp-09085",
+          "r10-comp-09086",
+          "r10-comp-09087",
+          "r10-comp-09092",
+          "r10-comp-09100",
+          "r10-comp-09137",
+          "r10-comp-09187",
+          "r10-comp-09189",
+          "r10-comp-09192",
+          "r10-comp-09196",
+          "r10-comp-09199",
+          "r10-comp-09207",
+          "r10-comp-09210",
+          "r10-comp-09222",
+          "r10-comp-09229",
+          "r10-comp-09240",
+          "r10-comp-09242",
+          "r10-comp-09249",
+          "r10-comp-09255",
+          "r10-comp-09258",
+          "r10-comp-09272",
+          "r10-comp-09273",
+          "r10-comp-09291",
+          "r10-comp-09292",
+          "r10-comp-09326",
+          "r10-comp-09329"
+        ],
+        "n_holdout": 706,
+        "n_train": 705,
+        "raw_thresholds": {
+          "audiobook": 0.364,
+          "comic": 0.364,
+          "course": 0.364,
+          "ebook": 0.364,
+          "game": 0.364,
+          "movie": 0.364,
+          "music": 0.364,
+          "software": 0.364,
+          "tv_show": 0.364,
+          "unknown": 0.364,
+          "xxx": 0.364
+        },
+        "tau_global": 0.364,
+        "thresholds": {
+          "audiobook": 0.364,
+          "comic": 0.36399999999999993,
+          "course": 0.364,
+          "ebook": 0.364,
+          "game": 0.364,
+          "movie": 0.364,
+          "music": 0.364,
+          "software": 0.364,
+          "tv_show": 0.364,
+          "unknown": 0.364,
+          "xxx": 0.364
+        },
+        "train_groups": [
+          "r10-comp-00018",
+          "r10-comp-00028",
+          "r10-comp-00030",
+          "r10-comp-00037",
+          "r10-comp-00044",
+          "r10-comp-00054",
+          "r10-comp-00068",
+          "r10-comp-00069",
+          "r10-comp-00087",
+          "r10-comp-00099",
+          "r10-comp-00102",
+          "r10-comp-00127",
+          "r10-comp-00134",
+          "r10-comp-00137",
+          "r10-comp-00144",
+          "r10-comp-00146",
+          "r10-comp-00169",
+          "r10-comp-00189",
+          "r10-comp-00207",
+          "r10-comp-00208",
+          "r10-comp-00213",
+          "r10-comp-00233",
+          "r10-comp-00268",
+          "r10-comp-00280",
+          "r10-comp-00315",
+          "r10-comp-00320",
+          "r10-comp-00335",
+          "r10-comp-00341",
+          "r10-comp-00344",
+          "r10-comp-00367",
+          "r10-comp-00387",
+          "r10-comp-00396",
+          "r10-comp-00399",
+          "r10-comp-00405",
+          "r10-comp-00409",
+          "r10-comp-00429",
+          "r10-comp-00431",
+          "r10-comp-00433",
+          "r10-comp-00464",
+          "r10-comp-00473",
+          "r10-comp-00477",
+          "r10-comp-00491",
+          "r10-comp-00533",
+          "r10-comp-00543",
+          "r10-comp-00549",
+          "r10-comp-00559",
+          "r10-comp-00564",
+          "r10-comp-00568",
+          "r10-comp-00605",
+          "r10-comp-00620",
+          "r10-comp-00684",
+          "r10-comp-00703",
+          "r10-comp-00711",
+          "r10-comp-00723",
+          "r10-comp-00745",
+          "r10-comp-00776",
+          "r10-comp-00783",
+          "r10-comp-00802",
+          "r10-comp-00811",
+          "r10-comp-00838",
+          "r10-comp-00887",
+          "r10-comp-00936",
+          "r10-comp-00950",
+          "r10-comp-00970",
+          "r10-comp-00990",
+          "r10-comp-00992",
+          "r10-comp-01000",
+          "r10-comp-01009",
+          "r10-comp-01019",
+          "r10-comp-01025",
+          "r10-comp-01029",
+          "r10-comp-01106",
+          "r10-comp-01114",
+          "r10-comp-01123",
+          "r10-comp-01141",
+          "r10-comp-01147",
+          "r10-comp-01154",
+          "r10-comp-01190",
+          "r10-comp-01307",
+          "r10-comp-01338",
+          "r10-comp-01429",
+          "r10-comp-01440",
+          "r10-comp-01483",
+          "r10-comp-01556",
+          "r10-comp-01559",
+          "r10-comp-01595",
+          "r10-comp-01601",
+          "r10-comp-01637",
+          "r10-comp-01667",
+          "r10-comp-01675",
+          "r10-comp-01735",
+          "r10-comp-01756",
+          "r10-comp-01831",
+          "r10-comp-01926",
+          "r10-comp-01949",
+          "r10-comp-01961",
+          "r10-comp-01963",
+          "r10-comp-02022",
+          "r10-comp-02069",
+          "r10-comp-02111",
+          "r10-comp-02112",
+          "r10-comp-02196",
+          "r10-comp-02198",
+          "r10-comp-02222",
+          "r10-comp-02289",
+          "r10-comp-02292",
+          "r10-comp-02310",
+          "r10-comp-02336",
+          "r10-comp-02411",
+          "r10-comp-02494",
+          "r10-comp-02557",
+          "r10-comp-02561",
+          "r10-comp-02576",
+          "r10-comp-02602",
+          "r10-comp-02699",
+          "r10-comp-02760",
+          "r10-comp-02794",
+          "r10-comp-02875",
+          "r10-comp-02880",
+          "r10-comp-02999",
+          "r10-comp-03234",
+          "r10-comp-03241",
+          "r10-comp-03251",
+          "r10-comp-03253",
+          "r10-comp-03267",
+          "r10-comp-03269",
+          "r10-comp-03272",
+          "r10-comp-03304",
+          "r10-comp-03318",
+          "r10-comp-03328",
+          "r10-comp-03348",
+          "r10-comp-03446",
+          "r10-comp-03453",
+          "r10-comp-03457",
+          "r10-comp-03493",
+          "r10-comp-03526",
+          "r10-comp-03538",
+          "r10-comp-03570",
+          "r10-comp-03585",
+          "r10-comp-03612",
+          "r10-comp-03635",
+          "r10-comp-03754",
+          "r10-comp-03766",
+          "r10-comp-03858",
+          "r10-comp-03881",
+          "r10-comp-03884",
+          "r10-comp-03885",
+          "r10-comp-03886",
+          "r10-comp-03887",
+          "r10-comp-03915",
+          "r10-comp-03929",
+          "r10-comp-03948",
+          "r10-comp-03950",
+          "r10-comp-03959",
+          "r10-comp-03993",
+          "r10-comp-03996",
+          "r10-comp-04016",
+          "r10-comp-04023",
+          "r10-comp-04025",
+          "r10-comp-04033",
+          "r10-comp-04034",
+          "r10-comp-04036",
+          "r10-comp-04047",
+          "r10-comp-04056",
+          "r10-comp-04073",
+          "r10-comp-04084",
+          "r10-comp-04088",
+          "r10-comp-04101",
+          "r10-comp-04108",
+          "r10-comp-04110",
+          "r10-comp-04120",
+          "r10-comp-04124",
+          "r10-comp-04130",
+          "r10-comp-04136",
+          "r10-comp-04151",
+          "r10-comp-04179",
+          "r10-comp-04182",
+          "r10-comp-04210",
+          "r10-comp-04211",
+          "r10-comp-04253",
+          "r10-comp-04287",
+          "r10-comp-04289",
+          "r10-comp-04292",
+          "r10-comp-04318",
+          "r10-comp-04330",
+          "r10-comp-04344",
+          "r10-comp-04396",
+          "r10-comp-04397",
+          "r10-comp-04442",
+          "r10-comp-04445",
+          "r10-comp-04476",
+          "r10-comp-04478",
+          "r10-comp-04479",
+          "r10-comp-04485",
+          "r10-comp-04521",
+          "r10-comp-04531",
+          "r10-comp-04532",
+          "r10-comp-04540",
+          "r10-comp-04552",
+          "r10-comp-04563",
+          "r10-comp-04570",
+          "r10-comp-04682",
+          "r10-comp-04704",
+          "r10-comp-04706",
+          "r10-comp-04709",
+          "r10-comp-04714",
+          "r10-comp-04716",
+          "r10-comp-04721",
+          "r10-comp-04738",
+          "r10-comp-04741",
+          "r10-comp-04798",
+          "r10-comp-04826",
+          "r10-comp-04834",
+          "r10-comp-04855",
+          "r10-comp-04863",
+          "r10-comp-04874",
+          "r10-comp-04883",
+          "r10-comp-04893",
+          "r10-comp-04901",
+          "r10-comp-04911",
+          "r10-comp-04912",
+          "r10-comp-04918",
+          "r10-comp-04935",
+          "r10-comp-04962",
+          "r10-comp-04971",
+          "r10-comp-04995",
+          "r10-comp-05006",
+          "r10-comp-05010",
+          "r10-comp-05014",
+          "r10-comp-05017",
+          "r10-comp-05026",
+          "r10-comp-05075",
+          "r10-comp-05079",
+          "r10-comp-05124",
+          "r10-comp-05126",
+          "r10-comp-05140",
+          "r10-comp-05147",
+          "r10-comp-05156",
+          "r10-comp-05163",
+          "r10-comp-05203",
+          "r10-comp-05205",
+          "r10-comp-05206",
+          "r10-comp-05216",
+          "r10-comp-05237",
+          "r10-comp-05308",
+          "r10-comp-05334",
+          "r10-comp-05336",
+          "r10-comp-05346",
+          "r10-comp-05357",
+          "r10-comp-05382",
+          "r10-comp-05404",
+          "r10-comp-05438",
+          "r10-comp-05444",
+          "r10-comp-05457",
+          "r10-comp-05503",
+          "r10-comp-05511",
+          "r10-comp-05529",
+          "r10-comp-05532",
+          "r10-comp-05537",
+          "r10-comp-05597",
+          "r10-comp-05615",
+          "r10-comp-05639",
+          "r10-comp-05641",
+          "r10-comp-05680",
+          "r10-comp-05718",
+          "r10-comp-05724",
+          "r10-comp-05727",
+          "r10-comp-05728",
+          "r10-comp-05768",
+          "r10-comp-05824",
+          "r10-comp-05825",
+          "r10-comp-05830",
+          "r10-comp-05834",
+          "r10-comp-05851",
+          "r10-comp-05867",
+          "r10-comp-05926",
+          "r10-comp-05951",
+          "r10-comp-05973",
+          "r10-comp-05991",
+          "r10-comp-05993",
+          "r10-comp-06007",
+          "r10-comp-06011",
+          "r10-comp-06015",
+          "r10-comp-06020",
+          "r10-comp-06062",
+          "r10-comp-06065",
+          "r10-comp-06077",
+          "r10-comp-06083",
+          "r10-comp-06091",
+          "r10-comp-06098",
+          "r10-comp-06146",
+          "r10-comp-06156",
+          "r10-comp-06158",
+          "r10-comp-06165",
+          "r10-comp-06172",
+          "r10-comp-06188",
+          "r10-comp-06203",
+          "r10-comp-06206",
+          "r10-comp-06208",
+          "r10-comp-06209",
+          "r10-comp-06259",
+          "r10-comp-06275",
+          "r10-comp-06276",
+          "r10-comp-06295",
+          "r10-comp-06303",
+          "r10-comp-06310",
+          "r10-comp-06319",
+          "r10-comp-06344",
+          "r10-comp-06367",
+          "r10-comp-06404",
+          "r10-comp-06414",
+          "r10-comp-06434",
+          "r10-comp-06441",
+          "r10-comp-06444",
+          "r10-comp-06460",
+          "r10-comp-06463",
+          "r10-comp-06486",
+          "r10-comp-06507",
+          "r10-comp-06520",
+          "r10-comp-06527",
+          "r10-comp-06528",
+          "r10-comp-06536",
+          "r10-comp-06540",
+          "r10-comp-06550",
+          "r10-comp-06556",
+          "r10-comp-06558",
+          "r10-comp-06586",
+          "r10-comp-06594",
+          "r10-comp-06620",
+          "r10-comp-06626",
+          "r10-comp-06627",
+          "r10-comp-06652",
+          "r10-comp-06656",
+          "r10-comp-06663",
+          "r10-comp-06665",
+          "r10-comp-06674",
+          "r10-comp-06683",
+          "r10-comp-06699",
+          "r10-comp-06704",
+          "r10-comp-06707",
+          "r10-comp-06717",
+          "r10-comp-06720",
+          "r10-comp-06729",
+          "r10-comp-06734",
+          "r10-comp-06788",
+          "r10-comp-06822",
+          "r10-comp-06838",
+          "r10-comp-06841",
+          "r10-comp-06846",
+          "r10-comp-06867",
+          "r10-comp-06873",
+          "r10-comp-06878",
+          "r10-comp-06879",
+          "r10-comp-06903",
+          "r10-comp-06909",
+          "r10-comp-06942",
+          "r10-comp-06949",
+          "r10-comp-06982",
+          "r10-comp-06990",
+          "r10-comp-07027",
+          "r10-comp-07033",
+          "r10-comp-07043",
+          "r10-comp-07050",
+          "r10-comp-07056",
+          "r10-comp-07060",
+          "r10-comp-07095",
+          "r10-comp-07100",
+          "r10-comp-07108",
+          "r10-comp-07112",
+          "r10-comp-07116",
+          "r10-comp-07165",
+          "r10-comp-07177",
+          "r10-comp-07202",
+          "r10-comp-07211",
+          "r10-comp-07212",
+          "r10-comp-07217",
+          "r10-comp-07228",
+          "r10-comp-07232",
+          "r10-comp-07241",
+          "r10-comp-07246",
+          "r10-comp-07270",
+          "r10-comp-07276",
+          "r10-comp-07283",
+          "r10-comp-07286",
+          "r10-comp-07291",
+          "r10-comp-07299",
+          "r10-comp-07312",
+          "r10-comp-07322",
+          "r10-comp-07328",
+          "r10-comp-07340",
+          "r10-comp-07357",
+          "r10-comp-07361",
+          "r10-comp-07369",
+          "r10-comp-07381",
+          "r10-comp-07406",
+          "r10-comp-07419",
+          "r10-comp-07434",
+          "r10-comp-07437",
+          "r10-comp-07450",
+          "r10-comp-07465",
+          "r10-comp-07468",
+          "r10-comp-07483",
+          "r10-comp-07499",
+          "r10-comp-07513",
+          "r10-comp-07520",
+          "r10-comp-07532",
+          "r10-comp-07538",
+          "r10-comp-07543",
+          "r10-comp-07547",
+          "r10-comp-07554",
+          "r10-comp-07561",
+          "r10-comp-07564",
+          "r10-comp-07566",
+          "r10-comp-07569",
+          "r10-comp-07584",
+          "r10-comp-07587",
+          "r10-comp-07625",
+          "r10-comp-07642",
+          "r10-comp-07644",
+          "r10-comp-07645",
+          "r10-comp-07675",
+          "r10-comp-07766",
+          "r10-comp-07795",
+          "r10-comp-07796",
+          "r10-comp-07808",
+          "r10-comp-07810",
+          "r10-comp-07837",
+          "r10-comp-07847",
+          "r10-comp-07856",
+          "r10-comp-07859",
+          "r10-comp-07871",
+          "r10-comp-07877",
+          "r10-comp-07878",
+          "r10-comp-07913",
+          "r10-comp-07941",
+          "r10-comp-07960",
+          "r10-comp-07992",
+          "r10-comp-08013",
+          "r10-comp-08023",
+          "r10-comp-08027",
+          "r10-comp-08028",
+          "r10-comp-08031",
+          "r10-comp-08034",
+          "r10-comp-08037",
+          "r10-comp-08039",
+          "r10-comp-08040",
+          "r10-comp-08058",
+          "r10-comp-08065",
+          "r10-comp-08074",
+          "r10-comp-08075",
+          "r10-comp-08079",
+          "r10-comp-08084",
+          "r10-comp-08086",
+          "r10-comp-08093",
+          "r10-comp-08095",
+          "r10-comp-08103",
+          "r10-comp-08104",
+          "r10-comp-08120",
+          "r10-comp-08122",
+          "r10-comp-08138",
+          "r10-comp-08139",
+          "r10-comp-08145",
+          "r10-comp-08152",
+          "r10-comp-08154",
+          "r10-comp-08160",
+          "r10-comp-08162",
+          "r10-comp-08167",
+          "r10-comp-08175",
+          "r10-comp-08192",
+          "r10-comp-08203",
+          "r10-comp-08208",
+          "r10-comp-08214",
+          "r10-comp-08219",
+          "r10-comp-08222",
+          "r10-comp-08230",
+          "r10-comp-08234",
+          "r10-comp-08241",
+          "r10-comp-08255",
+          "r10-comp-08260",
+          "r10-comp-08273",
+          "r10-comp-08275",
+          "r10-comp-08276",
+          "r10-comp-08287",
+          "r10-comp-08289",
+          "r10-comp-08299",
+          "r10-comp-08317",
+          "r10-comp-08360",
+          "r10-comp-08391",
+          "r10-comp-08393",
+          "r10-comp-08394",
+          "r10-comp-08405",
+          "r10-comp-08406",
+          "r10-comp-08409",
+          "r10-comp-08420",
+          "r10-comp-08438",
+          "r10-comp-08440",
+          "r10-comp-08452",
+          "r10-comp-08453",
+          "r10-comp-08459",
+          "r10-comp-08465",
+          "r10-comp-08474",
+          "r10-comp-08505",
+          "r10-comp-08555",
+          "r10-comp-08560",
+          "r10-comp-08573",
+          "r10-comp-08575",
+          "r10-comp-08581",
+          "r10-comp-08587",
+          "r10-comp-08617",
+          "r10-comp-08621",
+          "r10-comp-08626",
+          "r10-comp-08631",
+          "r10-comp-08632",
+          "r10-comp-08639",
+          "r10-comp-08645",
+          "r10-comp-08649",
+          "r10-comp-08668",
+          "r10-comp-08682",
+          "r10-comp-08683",
+          "r10-comp-08685",
+          "r10-comp-08689",
+          "r10-comp-08710",
+          "r10-comp-08719",
+          "r10-comp-08720",
+          "r10-comp-08753",
+          "r10-comp-08754",
+          "r10-comp-08757",
+          "r10-comp-08765",
+          "r10-comp-08766",
+          "r10-comp-08807",
+          "r10-comp-08813",
+          "r10-comp-08819",
+          "r10-comp-08823",
+          "r10-comp-08838",
+          "r10-comp-08852",
+          "r10-comp-08857",
+          "r10-comp-08865",
+          "r10-comp-08884",
+          "r10-comp-08895",
+          "r10-comp-08899",
+          "r10-comp-08900",
+          "r10-comp-08915",
+          "r10-comp-08916",
+          "r10-comp-08920",
+          "r10-comp-08923",
+          "r10-comp-08955",
+          "r10-comp-08970",
+          "r10-comp-08988",
+          "r10-comp-09029",
+          "r10-comp-09067",
+          "r10-comp-09072",
+          "r10-comp-09084",
+          "r10-comp-09095",
+          "r10-comp-09113",
+          "r10-comp-09117",
+          "r10-comp-09130",
+          "r10-comp-09145",
+          "r10-comp-09170",
+          "r10-comp-09173",
+          "r10-comp-09182",
+          "r10-comp-09185",
+          "r10-comp-09186",
+          "r10-comp-09212",
+          "r10-comp-09215",
+          "r10-comp-09233",
+          "r10-comp-09239",
+          "r10-comp-09246",
+          "r10-comp-09252",
+          "r10-comp-09274",
+          "r10-comp-09310",
+          "r10-comp-09312",
+          "r10-comp-09314",
+          "r10-comp-09318",
+          "r10-comp-09327"
+        ]
+      },
+      {
+        "balanced_error": 0.0502750811435321,
+        "counts": {
+          "audiobook": 29,
+          "comic": 67,
+          "course": 9,
+          "ebook": 34,
+          "game": 78,
+          "movie": 205,
+          "music": 97,
+          "software": 53,
+          "tv_show": 134,
+          "unknown": 0,
+          "xxx": 0
+        },
+        "heldout_fold": 1,
+        "holdout_groups": [
+          "r10-comp-00018",
+          "r10-comp-00028",
+          "r10-comp-00030",
+          "r10-comp-00037",
+          "r10-comp-00044",
+          "r10-comp-00054",
+          "r10-comp-00068",
+          "r10-comp-00069",
+          "r10-comp-00087",
+          "r10-comp-00099",
+          "r10-comp-00102",
+          "r10-comp-00127",
+          "r10-comp-00134",
+          "r10-comp-00137",
+          "r10-comp-00144",
+          "r10-comp-00146",
+          "r10-comp-00169",
+          "r10-comp-00189",
+          "r10-comp-00207",
+          "r10-comp-00208",
+          "r10-comp-00213",
+          "r10-comp-00233",
+          "r10-comp-00268",
+          "r10-comp-00280",
+          "r10-comp-00315",
+          "r10-comp-00320",
+          "r10-comp-00335",
+          "r10-comp-00341",
+          "r10-comp-00344",
+          "r10-comp-00367",
+          "r10-comp-00387",
+          "r10-comp-00396",
+          "r10-comp-00399",
+          "r10-comp-00405",
+          "r10-comp-00409",
+          "r10-comp-00429",
+          "r10-comp-00431",
+          "r10-comp-00433",
+          "r10-comp-00464",
+          "r10-comp-00473",
+          "r10-comp-00477",
+          "r10-comp-00491",
+          "r10-comp-00533",
+          "r10-comp-00543",
+          "r10-comp-00549",
+          "r10-comp-00559",
+          "r10-comp-00564",
+          "r10-comp-00568",
+          "r10-comp-00605",
+          "r10-comp-00620",
+          "r10-comp-00684",
+          "r10-comp-00703",
+          "r10-comp-00711",
+          "r10-comp-00723",
+          "r10-comp-00745",
+          "r10-comp-00776",
+          "r10-comp-00783",
+          "r10-comp-00802",
+          "r10-comp-00811",
+          "r10-comp-00838",
+          "r10-comp-00887",
+          "r10-comp-00936",
+          "r10-comp-00950",
+          "r10-comp-00970",
+          "r10-comp-00990",
+          "r10-comp-00992",
+          "r10-comp-01000",
+          "r10-comp-01009",
+          "r10-comp-01019",
+          "r10-comp-01025",
+          "r10-comp-01029",
+          "r10-comp-01106",
+          "r10-comp-01114",
+          "r10-comp-01123",
+          "r10-comp-01141",
+          "r10-comp-01147",
+          "r10-comp-01154",
+          "r10-comp-01190",
+          "r10-comp-01307",
+          "r10-comp-01338",
+          "r10-comp-01429",
+          "r10-comp-01440",
+          "r10-comp-01483",
+          "r10-comp-01556",
+          "r10-comp-01559",
+          "r10-comp-01595",
+          "r10-comp-01601",
+          "r10-comp-01637",
+          "r10-comp-01667",
+          "r10-comp-01675",
+          "r10-comp-01735",
+          "r10-comp-01756",
+          "r10-comp-01831",
+          "r10-comp-01926",
+          "r10-comp-01949",
+          "r10-comp-01961",
+          "r10-comp-01963",
+          "r10-comp-02022",
+          "r10-comp-02069",
+          "r10-comp-02111",
+          "r10-comp-02112",
+          "r10-comp-02196",
+          "r10-comp-02198",
+          "r10-comp-02222",
+          "r10-comp-02289",
+          "r10-comp-02292",
+          "r10-comp-02310",
+          "r10-comp-02336",
+          "r10-comp-02411",
+          "r10-comp-02494",
+          "r10-comp-02557",
+          "r10-comp-02561",
+          "r10-comp-02576",
+          "r10-comp-02602",
+          "r10-comp-02699",
+          "r10-comp-02760",
+          "r10-comp-02794",
+          "r10-comp-02875",
+          "r10-comp-02880",
+          "r10-comp-02999",
+          "r10-comp-03234",
+          "r10-comp-03241",
+          "r10-comp-03251",
+          "r10-comp-03253",
+          "r10-comp-03267",
+          "r10-comp-03269",
+          "r10-comp-03272",
+          "r10-comp-03304",
+          "r10-comp-03318",
+          "r10-comp-03328",
+          "r10-comp-03348",
+          "r10-comp-03446",
+          "r10-comp-03453",
+          "r10-comp-03457",
+          "r10-comp-03493",
+          "r10-comp-03526",
+          "r10-comp-03538",
+          "r10-comp-03570",
+          "r10-comp-03585",
+          "r10-comp-03612",
+          "r10-comp-03635",
+          "r10-comp-03754",
+          "r10-comp-03766",
+          "r10-comp-03858",
+          "r10-comp-03881",
+          "r10-comp-03884",
+          "r10-comp-03885",
+          "r10-comp-03886",
+          "r10-comp-03887",
+          "r10-comp-03915",
+          "r10-comp-03929",
+          "r10-comp-03948",
+          "r10-comp-03950",
+          "r10-comp-03959",
+          "r10-comp-03993",
+          "r10-comp-03996",
+          "r10-comp-04016",
+          "r10-comp-04023",
+          "r10-comp-04025",
+          "r10-comp-04033",
+          "r10-comp-04034",
+          "r10-comp-04036",
+          "r10-comp-04047",
+          "r10-comp-04056",
+          "r10-comp-04073",
+          "r10-comp-04084",
+          "r10-comp-04088",
+          "r10-comp-04101",
+          "r10-comp-04108",
+          "r10-comp-04110",
+          "r10-comp-04120",
+          "r10-comp-04124",
+          "r10-comp-04130",
+          "r10-comp-04136",
+          "r10-comp-04151",
+          "r10-comp-04179",
+          "r10-comp-04182",
+          "r10-comp-04210",
+          "r10-comp-04211",
+          "r10-comp-04253",
+          "r10-comp-04287",
+          "r10-comp-04289",
+          "r10-comp-04292",
+          "r10-comp-04318",
+          "r10-comp-04330",
+          "r10-comp-04344",
+          "r10-comp-04396",
+          "r10-comp-04397",
+          "r10-comp-04442",
+          "r10-comp-04445",
+          "r10-comp-04476",
+          "r10-comp-04478",
+          "r10-comp-04479",
+          "r10-comp-04485",
+          "r10-comp-04521",
+          "r10-comp-04531",
+          "r10-comp-04532",
+          "r10-comp-04540",
+          "r10-comp-04552",
+          "r10-comp-04563",
+          "r10-comp-04570",
+          "r10-comp-04682",
+          "r10-comp-04704",
+          "r10-comp-04706",
+          "r10-comp-04709",
+          "r10-comp-04714",
+          "r10-comp-04716",
+          "r10-comp-04721",
+          "r10-comp-04738",
+          "r10-comp-04741",
+          "r10-comp-04798",
+          "r10-comp-04826",
+          "r10-comp-04834",
+          "r10-comp-04855",
+          "r10-comp-04863",
+          "r10-comp-04874",
+          "r10-comp-04883",
+          "r10-comp-04893",
+          "r10-comp-04901",
+          "r10-comp-04911",
+          "r10-comp-04912",
+          "r10-comp-04918",
+          "r10-comp-04935",
+          "r10-comp-04962",
+          "r10-comp-04971",
+          "r10-comp-04995",
+          "r10-comp-05006",
+          "r10-comp-05010",
+          "r10-comp-05014",
+          "r10-comp-05017",
+          "r10-comp-05026",
+          "r10-comp-05075",
+          "r10-comp-05079",
+          "r10-comp-05124",
+          "r10-comp-05126",
+          "r10-comp-05140",
+          "r10-comp-05147",
+          "r10-comp-05156",
+          "r10-comp-05163",
+          "r10-comp-05203",
+          "r10-comp-05205",
+          "r10-comp-05206",
+          "r10-comp-05216",
+          "r10-comp-05237",
+          "r10-comp-05308",
+          "r10-comp-05334",
+          "r10-comp-05336",
+          "r10-comp-05346",
+          "r10-comp-05357",
+          "r10-comp-05382",
+          "r10-comp-05404",
+          "r10-comp-05438",
+          "r10-comp-05444",
+          "r10-comp-05457",
+          "r10-comp-05503",
+          "r10-comp-05511",
+          "r10-comp-05529",
+          "r10-comp-05532",
+          "r10-comp-05537",
+          "r10-comp-05597",
+          "r10-comp-05615",
+          "r10-comp-05639",
+          "r10-comp-05641",
+          "r10-comp-05680",
+          "r10-comp-05718",
+          "r10-comp-05724",
+          "r10-comp-05727",
+          "r10-comp-05728",
+          "r10-comp-05768",
+          "r10-comp-05824",
+          "r10-comp-05825",
+          "r10-comp-05830",
+          "r10-comp-05834",
+          "r10-comp-05851",
+          "r10-comp-05867",
+          "r10-comp-05926",
+          "r10-comp-05951",
+          "r10-comp-05973",
+          "r10-comp-05991",
+          "r10-comp-05993",
+          "r10-comp-06007",
+          "r10-comp-06011",
+          "r10-comp-06015",
+          "r10-comp-06020",
+          "r10-comp-06062",
+          "r10-comp-06065",
+          "r10-comp-06077",
+          "r10-comp-06083",
+          "r10-comp-06091",
+          "r10-comp-06098",
+          "r10-comp-06146",
+          "r10-comp-06156",
+          "r10-comp-06158",
+          "r10-comp-06165",
+          "r10-comp-06172",
+          "r10-comp-06188",
+          "r10-comp-06203",
+          "r10-comp-06206",
+          "r10-comp-06208",
+          "r10-comp-06209",
+          "r10-comp-06259",
+          "r10-comp-06275",
+          "r10-comp-06276",
+          "r10-comp-06295",
+          "r10-comp-06303",
+          "r10-comp-06310",
+          "r10-comp-06319",
+          "r10-comp-06344",
+          "r10-comp-06367",
+          "r10-comp-06404",
+          "r10-comp-06414",
+          "r10-comp-06434",
+          "r10-comp-06441",
+          "r10-comp-06444",
+          "r10-comp-06460",
+          "r10-comp-06463",
+          "r10-comp-06486",
+          "r10-comp-06507",
+          "r10-comp-06520",
+          "r10-comp-06527",
+          "r10-comp-06528",
+          "r10-comp-06536",
+          "r10-comp-06540",
+          "r10-comp-06550",
+          "r10-comp-06556",
+          "r10-comp-06558",
+          "r10-comp-06586",
+          "r10-comp-06594",
+          "r10-comp-06620",
+          "r10-comp-06626",
+          "r10-comp-06627",
+          "r10-comp-06652",
+          "r10-comp-06656",
+          "r10-comp-06663",
+          "r10-comp-06665",
+          "r10-comp-06674",
+          "r10-comp-06683",
+          "r10-comp-06699",
+          "r10-comp-06704",
+          "r10-comp-06707",
+          "r10-comp-06717",
+          "r10-comp-06720",
+          "r10-comp-06729",
+          "r10-comp-06734",
+          "r10-comp-06788",
+          "r10-comp-06822",
+          "r10-comp-06838",
+          "r10-comp-06841",
+          "r10-comp-06846",
+          "r10-comp-06867",
+          "r10-comp-06873",
+          "r10-comp-06878",
+          "r10-comp-06879",
+          "r10-comp-06903",
+          "r10-comp-06909",
+          "r10-comp-06942",
+          "r10-comp-06949",
+          "r10-comp-06982",
+          "r10-comp-06990",
+          "r10-comp-07027",
+          "r10-comp-07033",
+          "r10-comp-07043",
+          "r10-comp-07050",
+          "r10-comp-07056",
+          "r10-comp-07060",
+          "r10-comp-07095",
+          "r10-comp-07100",
+          "r10-comp-07108",
+          "r10-comp-07112",
+          "r10-comp-07116",
+          "r10-comp-07165",
+          "r10-comp-07177",
+          "r10-comp-07202",
+          "r10-comp-07211",
+          "r10-comp-07212",
+          "r10-comp-07217",
+          "r10-comp-07228",
+          "r10-comp-07232",
+          "r10-comp-07241",
+          "r10-comp-07246",
+          "r10-comp-07270",
+          "r10-comp-07276",
+          "r10-comp-07283",
+          "r10-comp-07286",
+          "r10-comp-07291",
+          "r10-comp-07299",
+          "r10-comp-07312",
+          "r10-comp-07322",
+          "r10-comp-07328",
+          "r10-comp-07340",
+          "r10-comp-07357",
+          "r10-comp-07361",
+          "r10-comp-07369",
+          "r10-comp-07381",
+          "r10-comp-07406",
+          "r10-comp-07419",
+          "r10-comp-07434",
+          "r10-comp-07437",
+          "r10-comp-07450",
+          "r10-comp-07465",
+          "r10-comp-07468",
+          "r10-comp-07483",
+          "r10-comp-07499",
+          "r10-comp-07513",
+          "r10-comp-07520",
+          "r10-comp-07532",
+          "r10-comp-07538",
+          "r10-comp-07543",
+          "r10-comp-07547",
+          "r10-comp-07554",
+          "r10-comp-07561",
+          "r10-comp-07564",
+          "r10-comp-07566",
+          "r10-comp-07569",
+          "r10-comp-07584",
+          "r10-comp-07587",
+          "r10-comp-07625",
+          "r10-comp-07642",
+          "r10-comp-07644",
+          "r10-comp-07645",
+          "r10-comp-07675",
+          "r10-comp-07766",
+          "r10-comp-07795",
+          "r10-comp-07796",
+          "r10-comp-07808",
+          "r10-comp-07810",
+          "r10-comp-07837",
+          "r10-comp-07847",
+          "r10-comp-07856",
+          "r10-comp-07859",
+          "r10-comp-07871",
+          "r10-comp-07877",
+          "r10-comp-07878",
+          "r10-comp-07913",
+          "r10-comp-07941",
+          "r10-comp-07960",
+          "r10-comp-07992",
+          "r10-comp-08013",
+          "r10-comp-08023",
+          "r10-comp-08027",
+          "r10-comp-08028",
+          "r10-comp-08031",
+          "r10-comp-08034",
+          "r10-comp-08037",
+          "r10-comp-08039",
+          "r10-comp-08040",
+          "r10-comp-08058",
+          "r10-comp-08065",
+          "r10-comp-08074",
+          "r10-comp-08075",
+          "r10-comp-08079",
+          "r10-comp-08084",
+          "r10-comp-08086",
+          "r10-comp-08093",
+          "r10-comp-08095",
+          "r10-comp-08103",
+          "r10-comp-08104",
+          "r10-comp-08120",
+          "r10-comp-08122",
+          "r10-comp-08138",
+          "r10-comp-08139",
+          "r10-comp-08145",
+          "r10-comp-08152",
+          "r10-comp-08154",
+          "r10-comp-08160",
+          "r10-comp-08162",
+          "r10-comp-08167",
+          "r10-comp-08175",
+          "r10-comp-08192",
+          "r10-comp-08203",
+          "r10-comp-08208",
+          "r10-comp-08214",
+          "r10-comp-08219",
+          "r10-comp-08222",
+          "r10-comp-08230",
+          "r10-comp-08234",
+          "r10-comp-08241",
+          "r10-comp-08255",
+          "r10-comp-08260",
+          "r10-comp-08273",
+          "r10-comp-08275",
+          "r10-comp-08276",
+          "r10-comp-08287",
+          "r10-comp-08289",
+          "r10-comp-08299",
+          "r10-comp-08317",
+          "r10-comp-08360",
+          "r10-comp-08391",
+          "r10-comp-08393",
+          "r10-comp-08394",
+          "r10-comp-08405",
+          "r10-comp-08406",
+          "r10-comp-08409",
+          "r10-comp-08420",
+          "r10-comp-08438",
+          "r10-comp-08440",
+          "r10-comp-08452",
+          "r10-comp-08453",
+          "r10-comp-08459",
+          "r10-comp-08465",
+          "r10-comp-08474",
+          "r10-comp-08505",
+          "r10-comp-08555",
+          "r10-comp-08560",
+          "r10-comp-08573",
+          "r10-comp-08575",
+          "r10-comp-08581",
+          "r10-comp-08587",
+          "r10-comp-08617",
+          "r10-comp-08621",
+          "r10-comp-08626",
+          "r10-comp-08631",
+          "r10-comp-08632",
+          "r10-comp-08639",
+          "r10-comp-08645",
+          "r10-comp-08649",
+          "r10-comp-08668",
+          "r10-comp-08682",
+          "r10-comp-08683",
+          "r10-comp-08685",
+          "r10-comp-08689",
+          "r10-comp-08710",
+          "r10-comp-08719",
+          "r10-comp-08720",
+          "r10-comp-08753",
+          "r10-comp-08754",
+          "r10-comp-08757",
+          "r10-comp-08765",
+          "r10-comp-08766",
+          "r10-comp-08807",
+          "r10-comp-08813",
+          "r10-comp-08819",
+          "r10-comp-08823",
+          "r10-comp-08838",
+          "r10-comp-08852",
+          "r10-comp-08857",
+          "r10-comp-08865",
+          "r10-comp-08884",
+          "r10-comp-08895",
+          "r10-comp-08899",
+          "r10-comp-08900",
+          "r10-comp-08915",
+          "r10-comp-08916",
+          "r10-comp-08920",
+          "r10-comp-08923",
+          "r10-comp-08955",
+          "r10-comp-08970",
+          "r10-comp-08988",
+          "r10-comp-09029",
+          "r10-comp-09067",
+          "r10-comp-09072",
+          "r10-comp-09084",
+          "r10-comp-09095",
+          "r10-comp-09113",
+          "r10-comp-09117",
+          "r10-comp-09130",
+          "r10-comp-09145",
+          "r10-comp-09170",
+          "r10-comp-09173",
+          "r10-comp-09182",
+          "r10-comp-09185",
+          "r10-comp-09186",
+          "r10-comp-09212",
+          "r10-comp-09215",
+          "r10-comp-09233",
+          "r10-comp-09239",
+          "r10-comp-09246",
+          "r10-comp-09252",
+          "r10-comp-09274",
+          "r10-comp-09310",
+          "r10-comp-09312",
+          "r10-comp-09314",
+          "r10-comp-09318",
+          "r10-comp-09327"
+        ],
+        "n_holdout": 705,
+        "n_train": 706,
+        "raw_thresholds": {
+          "audiobook": 0.399,
+          "comic": 0.399,
+          "course": 0.399,
+          "ebook": 0.399,
+          "game": 0.399,
+          "movie": 0.306,
+          "music": 0.399,
+          "software": 0.399,
+          "tv_show": 0.399,
+          "unknown": 0.399,
+          "xxx": 0.399
+        },
+        "tau_global": 0.399,
+        "thresholds": {
+          "audiobook": 0.399,
+          "comic": 0.399,
+          "course": 0.399,
+          "ebook": 0.399,
+          "game": 0.399,
+          "movie": 0.3178723404255319,
+          "music": 0.399,
+          "software": 0.399,
+          "tv_show": 0.399,
+          "unknown": 0.399,
+          "xxx": 0.399
+        },
+        "train_groups": [
+          "r10-comp-00005",
+          "r10-comp-00049",
+          "r10-comp-00059",
+          "r10-comp-00067",
+          "r10-comp-00084",
+          "r10-comp-00092",
+          "r10-comp-00122",
+          "r10-comp-00176",
+          "r10-comp-00204",
+          "r10-comp-00221",
+          "r10-comp-00236",
+          "r10-comp-00238",
+          "r10-comp-00240",
+          "r10-comp-00269",
+          "r10-comp-00311",
+          "r10-comp-00343",
+          "r10-comp-00371",
+          "r10-comp-00379",
+          "r10-comp-00384",
+          "r10-comp-00393",
+          "r10-comp-00450",
+          "r10-comp-00469",
+          "r10-comp-00542",
+          "r10-comp-00553",
+          "r10-comp-00558",
+          "r10-comp-00560",
+          "r10-comp-00563",
+          "r10-comp-00610",
+          "r10-comp-00614",
+          "r10-comp-00619",
+          "r10-comp-00626",
+          "r10-comp-00646",
+          "r10-comp-00675",
+          "r10-comp-00705",
+          "r10-comp-00732",
+          "r10-comp-00749",
+          "r10-comp-00768",
+          "r10-comp-00769",
+          "r10-comp-00777",
+          "r10-comp-00817",
+          "r10-comp-00848",
+          "r10-comp-00874",
+          "r10-comp-00892",
+          "r10-comp-01011",
+          "r10-comp-01014",
+          "r10-comp-01039",
+          "r10-comp-01047",
+          "r10-comp-01136",
+          "r10-comp-01277",
+          "r10-comp-01309",
+          "r10-comp-01320",
+          "r10-comp-01341",
+          "r10-comp-01353",
+          "r10-comp-01356",
+          "r10-comp-01405",
+          "r10-comp-01441",
+          "r10-comp-01445",
+          "r10-comp-01447",
+          "r10-comp-01485",
+          "r10-comp-01566",
+          "r10-comp-01622",
+          "r10-comp-01626",
+          "r10-comp-01647",
+          "r10-comp-01693",
+          "r10-comp-01725",
+          "r10-comp-01751",
+          "r10-comp-01760",
+          "r10-comp-01795",
+          "r10-comp-01808",
+          "r10-comp-01816",
+          "r10-comp-01826",
+          "r10-comp-01827",
+          "r10-comp-01860",
+          "r10-comp-01893",
+          "r10-comp-01907",
+          "r10-comp-01941",
+          "r10-comp-01972",
+          "r10-comp-01981",
+          "r10-comp-01999",
+          "r10-comp-02018",
+          "r10-comp-02137",
+          "r10-comp-02146",
+          "r10-comp-02206",
+          "r10-comp-02236",
+          "r10-comp-02302",
+          "r10-comp-02305",
+          "r10-comp-02341",
+          "r10-comp-02361",
+          "r10-comp-02373",
+          "r10-comp-02396",
+          "r10-comp-02421",
+          "r10-comp-02448",
+          "r10-comp-02497",
+          "r10-comp-02548",
+          "r10-comp-02553",
+          "r10-comp-02591",
+          "r10-comp-02593",
+          "r10-comp-02600",
+          "r10-comp-02622",
+          "r10-comp-02640",
+          "r10-comp-02654",
+          "r10-comp-02698",
+          "r10-comp-02764",
+          "r10-comp-02824",
+          "r10-comp-02839",
+          "r10-comp-02930",
+          "r10-comp-02983",
+          "r10-comp-02990",
+          "r10-comp-03005",
+          "r10-comp-03040",
+          "r10-comp-03133",
+          "r10-comp-03188",
+          "r10-comp-03229",
+          "r10-comp-03239",
+          "r10-comp-03260",
+          "r10-comp-03265",
+          "r10-comp-03274",
+          "r10-comp-03282",
+          "r10-comp-03298",
+          "r10-comp-03300",
+          "r10-comp-03317",
+          "r10-comp-03384",
+          "r10-comp-03436",
+          "r10-comp-03535",
+          "r10-comp-03565",
+          "r10-comp-03586",
+          "r10-comp-03590",
+          "r10-comp-03597",
+          "r10-comp-03603",
+          "r10-comp-03633",
+          "r10-comp-03648",
+          "r10-comp-03649",
+          "r10-comp-03681",
+          "r10-comp-03711",
+          "r10-comp-03823",
+          "r10-comp-03838",
+          "r10-comp-03846",
+          "r10-comp-03847",
+          "r10-comp-03857",
+          "r10-comp-03859",
+          "r10-comp-03877",
+          "r10-comp-03892",
+          "r10-comp-03894",
+          "r10-comp-03916",
+          "r10-comp-03924",
+          "r10-comp-03942",
+          "r10-comp-03957",
+          "r10-comp-03963",
+          "r10-comp-04000",
+          "r10-comp-04029",
+          "r10-comp-04049",
+          "r10-comp-04114",
+          "r10-comp-04119",
+          "r10-comp-04139",
+          "r10-comp-04197",
+          "r10-comp-04238",
+          "r10-comp-04251",
+          "r10-comp-04270",
+          "r10-comp-04271",
+          "r10-comp-04278",
+          "r10-comp-04286",
+          "r10-comp-04297",
+          "r10-comp-04322",
+          "r10-comp-04340",
+          "r10-comp-04342",
+          "r10-comp-04349",
+          "r10-comp-04365",
+          "r10-comp-04385",
+          "r10-comp-04393",
+          "r10-comp-04438",
+          "r10-comp-04450",
+          "r10-comp-04494",
+          "r10-comp-04505",
+          "r10-comp-04534",
+          "r10-comp-04544",
+          "r10-comp-04555",
+          "r10-comp-04594",
+          "r10-comp-04596",
+          "r10-comp-04605",
+          "r10-comp-04637",
+          "r10-comp-04656",
+          "r10-comp-04657",
+          "r10-comp-04660",
+          "r10-comp-04671",
+          "r10-comp-04701",
+          "r10-comp-04717",
+          "r10-comp-04725",
+          "r10-comp-04740",
+          "r10-comp-04742",
+          "r10-comp-04753",
+          "r10-comp-04755",
+          "r10-comp-04762",
+          "r10-comp-04772",
+          "r10-comp-04776",
+          "r10-comp-04783",
+          "r10-comp-04796",
+          "r10-comp-04812",
+          "r10-comp-04827",
+          "r10-comp-04845",
+          "r10-comp-04871",
+          "r10-comp-04876",
+          "r10-comp-04879",
+          "r10-comp-04887",
+          "r10-comp-04898",
+          "r10-comp-04913",
+          "r10-comp-04919",
+          "r10-comp-04956",
+          "r10-comp-04966",
+          "r10-comp-04986",
+          "r10-comp-04990",
+          "r10-comp-05023",
+          "r10-comp-05027",
+          "r10-comp-05029",
+          "r10-comp-05038",
+          "r10-comp-05061",
+          "r10-comp-05070",
+          "r10-comp-05080",
+          "r10-comp-05081",
+          "r10-comp-05083",
+          "r10-comp-05099",
+          "r10-comp-05106",
+          "r10-comp-05111",
+          "r10-comp-05151",
+          "r10-comp-05157",
+          "r10-comp-05162",
+          "r10-comp-05168",
+          "r10-comp-05178",
+          "r10-comp-05218",
+          "r10-comp-05224",
+          "r10-comp-05234",
+          "r10-comp-05276",
+          "r10-comp-05309",
+          "r10-comp-05310",
+          "r10-comp-05316",
+          "r10-comp-05337",
+          "r10-comp-05349",
+          "r10-comp-05350",
+          "r10-comp-05352",
+          "r10-comp-05356",
+          "r10-comp-05366",
+          "r10-comp-05369",
+          "r10-comp-05370",
+          "r10-comp-05381",
+          "r10-comp-05383",
+          "r10-comp-05384",
+          "r10-comp-05389",
+          "r10-comp-05390",
+          "r10-comp-05427",
+          "r10-comp-05440",
+          "r10-comp-05452",
+          "r10-comp-05465",
+          "r10-comp-05466",
+          "r10-comp-05481",
+          "r10-comp-05486",
+          "r10-comp-05490",
+          "r10-comp-05539",
+          "r10-comp-05542",
+          "r10-comp-05545",
+          "r10-comp-05547",
+          "r10-comp-05553",
+          "r10-comp-05606",
+          "r10-comp-05621",
+          "r10-comp-05630",
+          "r10-comp-05653",
+          "r10-comp-05668",
+          "r10-comp-05682",
+          "r10-comp-05685",
+          "r10-comp-05688",
+          "r10-comp-05691",
+          "r10-comp-05711",
+          "r10-comp-05723",
+          "r10-comp-05725",
+          "r10-comp-05737",
+          "r10-comp-05744",
+          "r10-comp-05751",
+          "r10-comp-05755",
+          "r10-comp-05783",
+          "r10-comp-05789",
+          "r10-comp-05802",
+          "r10-comp-05849",
+          "r10-comp-05877",
+          "r10-comp-05880",
+          "r10-comp-05892",
+          "r10-comp-05908",
+          "r10-comp-05928",
+          "r10-comp-05957",
+          "r10-comp-05958",
+          "r10-comp-05980",
+          "r10-comp-06003",
+          "r10-comp-06019",
+          "r10-comp-06024",
+          "r10-comp-06032",
+          "r10-comp-06051",
+          "r10-comp-06057",
+          "r10-comp-06079",
+          "r10-comp-06089",
+          "r10-comp-06109",
+          "r10-comp-06139",
+          "r10-comp-06140",
+          "r10-comp-06151",
+          "r10-comp-06194",
+          "r10-comp-06196",
+          "r10-comp-06216",
+          "r10-comp-06230",
+          "r10-comp-06231",
+          "r10-comp-06286",
+          "r10-comp-06293",
+          "r10-comp-06306",
+          "r10-comp-06330",
+          "r10-comp-06354",
+          "r10-comp-06366",
+          "r10-comp-06391",
+          "r10-comp-06412",
+          "r10-comp-06415",
+          "r10-comp-06420",
+          "r10-comp-06423",
+          "r10-comp-06451",
+          "r10-comp-06457",
+          "r10-comp-06467",
+          "r10-comp-06498",
+          "r10-comp-06505",
+          "r10-comp-06523",
+          "r10-comp-06524",
+          "r10-comp-06545",
+          "r10-comp-06579",
+          "r10-comp-06590",
+          "r10-comp-06595",
+          "r10-comp-06638",
+          "r10-comp-06654",
+          "r10-comp-06676",
+          "r10-comp-06691",
+          "r10-comp-06702",
+          "r10-comp-06711",
+          "r10-comp-06721",
+          "r10-comp-06744",
+          "r10-comp-06779",
+          "r10-comp-06785",
+          "r10-comp-06802",
+          "r10-comp-06815",
+          "r10-comp-06843",
+          "r10-comp-06863",
+          "r10-comp-06874",
+          "r10-comp-06885",
+          "r10-comp-06886",
+          "r10-comp-06911",
+          "r10-comp-06918",
+          "r10-comp-06927",
+          "r10-comp-06930",
+          "r10-comp-06931",
+          "r10-comp-06943",
+          "r10-comp-06959",
+          "r10-comp-06962",
+          "r10-comp-06971",
+          "r10-comp-06995",
+          "r10-comp-07009",
+          "r10-comp-07010",
+          "r10-comp-07014",
+          "r10-comp-07017",
+          "r10-comp-07018",
+          "r10-comp-07024",
+          "r10-comp-07025",
+          "r10-comp-07037",
+          "r10-comp-07069",
+          "r10-comp-07070",
+          "r10-comp-07076",
+          "r10-comp-07092",
+          "r10-comp-07097",
+          "r10-comp-07105",
+          "r10-comp-07110",
+          "r10-comp-07123",
+          "r10-comp-07127",
+          "r10-comp-07148",
+          "r10-comp-07153",
+          "r10-comp-07196",
+          "r10-comp-07224",
+          "r10-comp-07229",
+          "r10-comp-07239",
+          "r10-comp-07256",
+          "r10-comp-07268",
+          "r10-comp-07271",
+          "r10-comp-07284",
+          "r10-comp-07288",
+          "r10-comp-07293",
+          "r10-comp-07308",
+          "r10-comp-07313",
+          "r10-comp-07334",
+          "r10-comp-07347",
+          "r10-comp-07353",
+          "r10-comp-07365",
+          "r10-comp-07377",
+          "r10-comp-07387",
+          "r10-comp-07391",
+          "r10-comp-07404",
+          "r10-comp-07408",
+          "r10-comp-07410",
+          "r10-comp-07420",
+          "r10-comp-07423",
+          "r10-comp-07435",
+          "r10-comp-07441",
+          "r10-comp-07451",
+          "r10-comp-07453",
+          "r10-comp-07458",
+          "r10-comp-07466",
+          "r10-comp-07475",
+          "r10-comp-07487",
+          "r10-comp-07511",
+          "r10-comp-07517",
+          "r10-comp-07522",
+          "r10-comp-07530",
+          "r10-comp-07531",
+          "r10-comp-07533",
+          "r10-comp-07537",
+          "r10-comp-07539",
+          "r10-comp-07540",
+          "r10-comp-07548",
+          "r10-comp-07579",
+          "r10-comp-07585",
+          "r10-comp-07631",
+          "r10-comp-07641",
+          "r10-comp-07654",
+          "r10-comp-07657",
+          "r10-comp-07658",
+          "r10-comp-07660",
+          "r10-comp-07669",
+          "r10-comp-07674",
+          "r10-comp-07687",
+          "r10-comp-07750",
+          "r10-comp-07755",
+          "r10-comp-07767",
+          "r10-comp-07785",
+          "r10-comp-07786",
+          "r10-comp-07789",
+          "r10-comp-07801",
+          "r10-comp-07819",
+          "r10-comp-07821",
+          "r10-comp-07824",
+          "r10-comp-07827",
+          "r10-comp-07869",
+          "r10-comp-07884",
+          "r10-comp-07886",
+          "r10-comp-07887",
+          "r10-comp-07889",
+          "r10-comp-07895",
+          "r10-comp-07914",
+          "r10-comp-07933",
+          "r10-comp-07944",
+          "r10-comp-07972",
+          "r10-comp-07979",
+          "r10-comp-08007",
+          "r10-comp-08019",
+          "r10-comp-08026",
+          "r10-comp-08042",
+          "r10-comp-08048",
+          "r10-comp-08049",
+          "r10-comp-08050",
+          "r10-comp-08057",
+          "r10-comp-08068",
+          "r10-comp-08069",
+          "r10-comp-08070",
+          "r10-comp-08082",
+          "r10-comp-08087",
+          "r10-comp-08088",
+          "r10-comp-08117",
+          "r10-comp-08124",
+          "r10-comp-08126",
+          "r10-comp-08129",
+          "r10-comp-08132",
+          "r10-comp-08148",
+          "r10-comp-08163",
+          "r10-comp-08171",
+          "r10-comp-08189",
+          "r10-comp-08190",
+          "r10-comp-08196",
+          "r10-comp-08202",
+          "r10-comp-08212",
+          "r10-comp-08248",
+          "r10-comp-08253",
+          "r10-comp-08254",
+          "r10-comp-08257",
+          "r10-comp-08263",
+          "r10-comp-08274",
+          "r10-comp-08293",
+          "r10-comp-08294",
+          "r10-comp-08298",
+          "r10-comp-08301",
+          "r10-comp-08302",
+          "r10-comp-08333",
+          "r10-comp-08337",
+          "r10-comp-08356",
+          "r10-comp-08367",
+          "r10-comp-08378",
+          "r10-comp-08379",
+          "r10-comp-08383",
+          "r10-comp-08400",
+          "r10-comp-08408",
+          "r10-comp-08419",
+          "r10-comp-08433",
+          "r10-comp-08470",
+          "r10-comp-08477",
+          "r10-comp-08490",
+          "r10-comp-08493",
+          "r10-comp-08507",
+          "r10-comp-08515",
+          "r10-comp-08530",
+          "r10-comp-08538",
+          "r10-comp-08539",
+          "r10-comp-08556",
+          "r10-comp-08569",
+          "r10-comp-08590",
+          "r10-comp-08598",
+          "r10-comp-08634",
+          "r10-comp-08657",
+          "r10-comp-08674",
+          "r10-comp-08684",
+          "r10-comp-08686",
+          "r10-comp-08690",
+          "r10-comp-08695",
+          "r10-comp-08702",
+          "r10-comp-08706",
+          "r10-comp-08721",
+          "r10-comp-08742",
+          "r10-comp-08776",
+          "r10-comp-08795",
+          "r10-comp-08803",
+          "r10-comp-08806",
+          "r10-comp-08816",
+          "r10-comp-08817",
+          "r10-comp-08824",
+          "r10-comp-08835",
+          "r10-comp-08841",
+          "r10-comp-08843",
+          "r10-comp-08855",
+          "r10-comp-08870",
+          "r10-comp-08893",
+          "r10-comp-08909",
+          "r10-comp-08926",
+          "r10-comp-08932",
+          "r10-comp-08941",
+          "r10-comp-08946",
+          "r10-comp-08956",
+          "r10-comp-08972",
+          "r10-comp-08985",
+          "r10-comp-09006",
+          "r10-comp-09031",
+          "r10-comp-09041",
+          "r10-comp-09044",
+          "r10-comp-09051",
+          "r10-comp-09063",
+          "r10-comp-09066",
+          "r10-comp-09085",
+          "r10-comp-09086",
+          "r10-comp-09087",
+          "r10-comp-09092",
+          "r10-comp-09100",
+          "r10-comp-09137",
+          "r10-comp-09187",
+          "r10-comp-09189",
+          "r10-comp-09192",
+          "r10-comp-09196",
+          "r10-comp-09199",
+          "r10-comp-09207",
+          "r10-comp-09210",
+          "r10-comp-09222",
+          "r10-comp-09229",
+          "r10-comp-09240",
+          "r10-comp-09242",
+          "r10-comp-09249",
+          "r10-comp-09255",
+          "r10-comp-09258",
+          "r10-comp-09272",
+          "r10-comp-09273",
+          "r10-comp-09291",
+          "r10-comp-09292",
+          "r10-comp-09326",
+          "r10-comp-09329"
+        ]
+      }
+    ],
+    "m": 30.0,
+    "n_folds": 2,
+    "n_rows": 1411,
+    "n_scored": 1411,
+    "oof_balanced_error": 0.041957059005251776,
+    "raw_thresholds": {
+      "audiobook": 0.399,
+      "comic": 0.399,
+      "course": 0.399,
+      "ebook": 0.399,
+      "game": 0.399,
+      "movie": 0.306,
+      "music": 0.399,
+      "software": 0.399,
+      "tv_show": 0.399,
+      "unknown": 0.399,
+      "xxx": 0.399
+    },
+    "schema": "armiger-r12-owner-scope-v1",
+    "split": "val",
+    "tau_global": 0.399,
+    "thresholds": {
+      "audiobook": 0.399,
+      "comic": 0.39899999999999997,
+      "course": 0.399,
+      "ebook": 0.399,
+      "game": 0.399,
+      "movie": 0.31285503685503685,
+      "music": 0.399,
+      "software": 0.399,
+      "tv_show": 0.399,
+      "unknown": 0.399,
+      "xxx": 0.399
+    },
+    "val_sha256": "36b66664e7f6ee49e1aae13fc7338294d845b2c7842e682e71a3485b050d7777"
+  },
+  "r13_allow_categories": [
+    "movie",
+    "tv_show"
+  ],
+  "stratum_weighted_refit": {
+    "spec_targets": {
+      "allowed_coverage_at_least_98pct_test": false,
+      "allowed_coverage_at_least_98pct_val": true,
+      "course_leak_below_10pct": false
+    },
+    "val_audit": {
+      "ht_weighted_global": {
+        "allowed_coverage": 0.98,
+        "course_leak_rate": 0.4524,
+        "course_leaked": 19,
+        "excluded_recall": 0.9471
+      },
+      "legacy_global": {
+        "allowed_coverage": 0.9811,
+        "course_leak_rate": 0.4524,
+        "course_leaked": 19,
+        "excluded_recall": 0.9471
+      },
+      "mondrian_by_gold_category_oracle": {
+        "allowed_coverage": 0.9845,
+        "course_leak_rate": 0.4524,
+        "course_leaked": 19,
+        "excluded_recall": 0.9471
+      },
+      "mondrian_by_predicted_category": {
+        "allowed_coverage": 0.98,
+        "course_leak_rate": 0.4524,
+        "course_leaked": 19,
+        "excluded_recall": 0.949
+      },
+      "n": 1411,
+      "n_allowed": 901,
+      "n_course_excluded": 42
+    },
+    "weights": {
+      "cells": {
+        "allowed_type|game": 153,
+        "allowed_type|movie": 311,
+        "allowed_type|software": 123,
+        "allowed_type|tv_show": 314,
+        "excluded|audiobook": 61,
+        "excluded|comic": 163,
+        "excluded|course": 42,
+        "excluded|ebook": 60,
+        "excluded|music": 184
+      },
+      "class": "owner_scope",
+      "method": "horvitz_thompson_inverse_stratum w_i = 1/n_{c,k}",
+      "stratum": "category"
     }
   },
-  "calibration_version": "v3.0-gold-mit3-final-guarded",
   "temperature_audit": {
+    "anime": {
+      "acc_pct": 81.8035,
+      "best_T_crossfit": 0.75,
+      "ece5_at_T1_pct": 3.3623,
+      "ece5_guarded_pct": 1.0578,
+      "fold_Ts": [
+        0.825,
+        0.675
+      ],
+      "n": 621,
+      "shipped_T_guarded": 0.75,
+      "weighted_nll_at_T1": 0.345181,
+      "weighted_nll_at_best_T": 0.335153,
+      "weighting": "2-fold group cross-fitted horvitz_thompson stratum_weight"
+    },
     "category": {
-      "n": 995,
-      "nll_at_T1": 0.284156,
-      "nll_at_best_T": 0.250881,
-      "best_T_unclamped": 0.65,
-      "shipped_T_guarded": 0.65,
-      "ece5_at_T1_pct": 6.6104,
-      "ece5_guarded_pct": 2.1656,
-      "acc_pct": 91.4573
+      "acc_pct": 84.55,
+      "best_T_crossfit": 1.2,
+      "ece5_at_T1_pct": 3.2368,
+      "ece5_guarded_pct": 6.287,
+      "fold_Ts": [
+        1.25,
+        1.15
+      ],
+      "n": 1411,
+      "shipped_T_guarded": 1.2,
+      "weighted_nll_at_T1": 0.597522,
+      "weighted_nll_at_best_T": 0.58716,
+      "weighting": "2-fold group cross-fitted horvitz_thompson stratum_weight"
+    },
+    "english_subs": {
+      "acc_pct": 97.1698,
+      "best_T_crossfit": 0.55,
+      "ece5_at_T1_pct": 4.3801,
+      "ece5_guarded_pct": 1.8806,
+      "fold_Ts": [
+        0.6,
+        0.5
+      ],
+      "n": 212,
+      "shipped_T_guarded": 0.55,
+      "weighted_nll_at_T1": 0.123028,
+      "weighted_nll_at_best_T": 0.087029,
+      "weighting": "2-fold group cross-fitted horvitz_thompson stratum_weight"
     },
     "lang": {
-      "n": 368,
-      "nll_at_T1": 0.308272,
-      "nll_at_best_T": 0.289053,
-      "best_T_unclamped": 0.7,
-      "shipped_T_guarded": 0.7,
-      "ece5_at_T1_pct": 6.9697,
-      "ece5_guarded_pct": 3.2334,
-      "acc_pct": 89.9457
+      "acc_pct": 82.7434,
+      "best_T_crossfit": 1.5375,
+      "ece5_at_T1_pct": 8.9621,
+      "ece5_guarded_pct": 2.3818,
+      "fold_Ts": [
+        1.675,
+        1.4
+      ],
+      "n": 226,
+      "shipped_T_guarded": 1.5375,
+      "weighted_nll_at_T1": 0.358405,
+      "weighted_nll_at_best_T": 0.324181,
+      "weighting": "2-fold group cross-fitted horvitz_thompson stratum_weight"
     },
     "owner_scope": {
-      "n": 995,
-      "nll_at_T1": 0.042003,
-      "nll_at_best_T": 0.027084,
-      "best_T_unclamped": 0.55,
-      "shipped_T_guarded": 0.55,
-      "ece5_at_T1_pct": 2.1499,
-      "ece5_guarded_pct": 0.202,
-      "acc_pct": 98.995
+      "acc_pct": 98.4408,
+      "best_T_crossfit": 1.8875,
+      "ece5_at_T1_pct": 0.9298,
+      "ece5_guarded_pct": 2.6221,
+      "fold_Ts": [
+        2.05,
+        1.725
+      ],
+      "n": 1411,
+      "shipped_T_guarded": 1.8875,
+      "weighted_nll_at_T1": 0.200121,
+      "weighted_nll_at_best_T": 0.147816,
+      "weighting": "2-fold group cross-fitted horvitz_thompson stratum_weight"
     },
     "title_language": {
-      "n": 566,
-      "nll_at_T1": 0.137678,
-      "nll_at_best_T": 0.13748,
-      "best_T_unclamped": 0.95,
-      "shipped_T_guarded": 0.95,
-      "ece5_at_T1_pct": 1.0472,
-      "ece5_guarded_pct": 0.7014,
-      "acc_pct": 95.4064
+      "acc_pct": 97.832,
+      "best_T_crossfit": 1.0125,
+      "ece5_at_T1_pct": 0.7029,
+      "ece5_guarded_pct": 0.7498,
+      "fold_Ts": [
+        1.175,
+        0.85
+      ],
+      "n": 369,
+      "shipped_T_guarded": 1.0125,
+      "weighted_nll_at_T1": 0.070129,
+      "weighted_nll_at_best_T": 0.070032,
+      "weighting": "2-fold group cross-fitted horvitz_thompson stratum_weight"
+    }
+  },
+  "temperature_scaling_stop_fit": {
+    "anime": {
+      "cal_temp_scaled": {
+        "fitted_on": "snap_r13_20261024T140340Z_064c8e6ccb1f_val_2fold_ht_guarded",
+        "n": 621
+      },
+      "temperature_T": 0.75
     },
-    "english_subs": {
-      "n": 137,
-      "nll_at_T1": 0.189409,
-      "nll_at_best_T": 0.132055,
-      "best_T_unclamped": 0.5,
-      "shipped_T_guarded": 0.5,
-      "ece5_at_T1_pct": 9.9213,
-      "ece5_guarded_pct": 2.5349,
-      "acc_pct": 96.3504
+    "category": {
+      "cal_temp_scaled": {
+        "fitted_on": "snap_r13_20261024T140340Z_064c8e6ccb1f_val_2fold_ht_guarded",
+        "n": 1411
+      },
+      "temperature_T": 1.2
     },
-    "anime": {
-      "n": 243,
-      "nll_at_T1": 0.391146,
-      "nll_at_best_T": 0.389958,
-      "best_T_unclamped": 0.9,
-      "shipped_T_guarded": 0.9,
-      "ece5_at_T1_pct": 3.8909,
-      "ece5_guarded_pct": 2.9506,
-      "acc_pct": 84.7737
+    "english_subs": {
+      "cal_temp_scaled": {
+        "fitted_on": "snap_r13_20261024T140340Z_064c8e6ccb1f_val_2fold_ht_guarded",
+        "n": 212
+      },
+      "temperature_T": 0.55
     },
-    "adult": {
-      "inherited": true,
-      "reason": "no Gold-val label support; retained wave5a fit"
+    "lang": {
+      "cal_temp_scaled": {
+        "fitted_on": "snap_r13_20261024T140340Z_064c8e6ccb1f_val_2fold_ht_guarded",
+        "n": 226
+      },
+      "temperature_T": 1.5375
     },
-    "junk": {
-      "inherited": true,
-      "reason": "no Gold-val label support; retained wave5a fit"
-    }
-  },
-  "mondrian_thresholds": {
-    "adult": 0.5451,
-    "junk": 0.101,
-    "owner_scope": 0.477
-  },
-  "mondrian_audit": {
     "owner_scope": {
-      "alpha": 0.02,
-      "n_neg": 256,
-      "n_pos": 739,
-      "val_fpr_at_thr": 0.015625,
-      "val_recall_at_thr": 0.994587,
-      "method": "split-conformal FPR quantile ceil((n+1)(1-alpha)) on val negatives, temperature-scaled probs"
+      "cal_temp_scaled": {
+        "fitted_on": "snap_r13_20261024T140340Z_064c8e6ccb1f_val_2fold_ht_guarded",
+        "n": 1411
+      },
+      "temperature_T": 1.8875
+    },
+    "title_language": {
+      "cal_temp_scaled": {
+        "fitted_on": "snap_r13_20261024T140340Z_064c8e6ccb1f_val_2fold_ht_guarded",
+        "n": 369
+      },
+      "temperature_T": 1.0125
     }
-  },
-  "fitted_snapshot_id": "snap_wave13_r5_20261021T115351Z_bfb9dfb67b41",
-  "calibrated_onnx_fp32_sha256": "6459a20d7bf45d46d59efbcb50ffb8a519bacda14ae36403dcc510eceaa38f44",
-  "mondrian_fitted_calibration_split": {
-    "adult": 0.799935,
-    "junk": 0.259358,
-    "owner_scope": 0.944382,
-    "method": "split-conformal FPR quantile on packed calibration split (512), temperature-scaled; NOT shipped as gates (recall cost on confirmation) - see mondrian_refit_report"
-  },
-  "mondrian_provenance": "Inherited production gates retained for v3.0.0 (higher adult/owner recall on confirmation splits than calibration-fitted FPR gates; fitted alternates recorded for operators).",
-  "calibrated_onnx_int8_sha256": "a0dab886be6252739d4c89ce01d65d8d2135204beaec6b00159d038cf420f329"
+  }
 }

config.json

@@ -1,28 +1,27 @@
 {
-  "model_name": "armiger-ultra",
-  "version": "3.0.0",
-  "bundle_type": "unified_armiger_plus_ultra_plus_swarm",
-  "architecture": "armiger-v3-byte-rope-transformer-9head (incl. byte-level span_bio + 7x7 BIO Viterbi) + residual-swarm-health-adapter",
+  "model_name": "armiger",
+  "version": "3.3.0",
+  "architecture": "armiger-v2-byte-rope-transformer-8head",
+  "checkpoint": "H350000_Curated_Wave2-seed0 (direct-side hardened junk head)",
+  "format": "onnx-int8-dynamic",
+  "size_bytes": 8283542,
+  "sha256": "0f7496a70565145d09a8b29b09de9b99171cf483e5c32ff32e89df1931231401",
   "artifacts": {
-    "armiger_cpu_int8_onnx": {
-      "file": "armiger.int8.onnx",
-      "size_bytes": 15721824,
-      "sha256": "a0dab886be6252739d4c89ce01d65d8d2135204beaec6b00159d038cf420f329"
+    "armiger.onnx": {
+      "size_bytes": 17599636,
+      "sha256": "c0e96936038988c7465b7fe041c4dc3c92df5a8cb4f56c2666271cd4d3e79420"
     },
-    "armiger_ultra_fp32_onnx": {
-      "file": "armiger_ultra.fp32.onnx",
-      "size_bytes": 32543999,
-      "sha256": "6459a20d7bf45d46d59efbcb50ffb8a519bacda14ae36403dcc510eceaa38f44"
+    "calibration.json": {
+      "size_bytes": 76612,
+      "sha256": "300387779dc16292dd9e6be038ce9dd60e5bdb0ee929b383dcd4e51715f8b5f8"
     },
-    "armiger_ultra_pytorch": {
-      "file": "armiger_ultra.pt",
-      "size_bytes": 32493659,
-      "sha256": "44cdcf1fac8ebc036262b2d3150b3ba0f27002669bf81e3480b1bc65e3ef8156"
+    "vocab.json": {
+      "size_bytes": 39996,
+      "sha256": "c10afea430188e0207752e93bf0b340fbb585858684037c5134a477cbc0dd7bb"
     },
-    "swarm_health_adapter": {
-      "file": "swarm_adapter.pt",
-      "size_bytes": 131718,
-      "sha256": "85effcb9e70af7bff6047d4ae45d2155444e9b691dc84431f19ad14f9daee9ea"
+    "armiger_inference.py": {
+      "size_bytes": 38228,
+      "sha256": "c345587c57cecc518626852d0d8fcacf5ebb1576c10c0df6608f851a9ec72c31"
     }
   },
   "heads": {
@@ -68,15 +67,6 @@
     "title_language": [
       "english_title",
       "non_english_title"
-    ],
-    "span_bio": [
-      "O",
-      "B-TITLE",
-      "I-TITLE",
-      "B-YEAR",
-      "I-YEAR",
-      "B-EP",
-      "I-EP"
     ]
   },
   "mondrian_thresholds": {
@@ -84,118 +74,91 @@
     "junk": 0.101,
     "owner_scope": 0.477
   },
-  "benchmarks": {
-    "gold_standard_11class_category_acc": 94.85,
-    "movie_vs_tv_acc": 95.83,
-    "catalog_matching_rate_acc": 95.06,
-    "audio_language_acc": 96.7,
-    "anime_and_dub_acc": 99.61,
-    "adult_safety_gate_acc": 98.49,
-    "swarm_liveliness_auroc": 96.83,
-    "fake_seeder_honeypot_recall": 100.0,
-    "overall_6dim_composite_mean": 95.66,
-    "gpu_batched_latency_ms": 0.5,
-    "gpu_single_item_latency_ms": 1.12,
-    "cpu_int8_batched_latency_ms": 0.42,
-    "junk_malware_filter_beyond_n977_balanced_acc": 99.23,
-    "oct15_junk_status": "n_pos = 1, not estimable",
-    "public_tracker_swarm_auroc": 92.42,
-    "cpu_int8_single_item_latency_ms": 2.512,
-    "cpu_fp32_single_item_latency_ms": 2.637,
-    "cpu_int8_batch64_items_per_sec": 396.9,
-    "cpu_fp32_batch64_items_per_sec": 376.0
-  },
-  "bundled_plugins": {
-    "armiger-swarm-survival": {
-      "standalone_repo": "NorviTech/armiger-swarm-survival",
-      "files": [
-        "swarm_adapter.pt",
-        "swarm_survival.py"
-      ],
-      "sha256": {
-        "swarm_adapter.pt": "85effcb9e70af7bff6047d4ae45d2155444e9b691dc84431f19ad14f9daee9ea",
-        "swarm_survival.py": "9dfbe7c4961f5a53bb4e40fc4450ebf958398157148d9f54da100d75dd24caf0"
-      }
+  "benchmarks_unmutated_ground_truth": {
+    "oct15_confirmation_n2835": {
+      "standalone_neural_11class_acc": 95.06,
+      "fair_hybrid_with_zero_cue_plugin_11class_acc": 95.49,
+      "standalone_neural_movie_vs_tv_acc": 96.6,
+      "fair_hybrid_movie_vs_tv_acc": 97.15,
+      "standalone_neural_catalog_matching_acc": 95.85,
+      "fair_hybrid_catalog_matching_acc": 96.39,
+      "standalone_neural_audio_lang_binary_n545_acc": 96.88,
+      "with_audio_guard_binary_n545_acc": 97.8,
+      "audio_lang_3class_n772_acc": 92.75,
+      "anime_n507_acc": 99.61,
+      "adult_n2781_acc": 98.53,
+      "junk_n2170_acc": 100.0,
+      "owner_scope_n2669_acc": 98.65,
+      "title_language_n969_acc": 93.7
     },
-    "armiger-swarm-priors": {
-      "standalone_repo": "NorviTech/armiger-swarm-priors",
-      "files": [
-        "swarm_priors.py"
-      ],
-      "sha256": {
-        "swarm_priors.py": "49b2b6857802606158e4a1de8cdc335e485be83aaec5405b9f2fd103ca90b394"
-      }
+    "fresh_confirmation_n1402": {
+      "standalone_neural_11class_acc": 94.44,
+      "fair_hybrid_11class_acc": 94.58,
+      "adult_n1393_acc": 98.21,
+      "junk_n1291_acc": 100.0,
+      "anime_n253_acc": 99.6
     },
-    "armiger-zero-cue-catalog": {
-      "standalone_repo": "NorviTech/armiger-zero-cue-catalog",
-      "files": [
-        "zero_cue_plugin.py",
-        "validated_zero_cue_catalog.json"
-      ],
-      "sha256": {
-        "zero_cue_plugin.py": "90039f19d36f2bcd0f0103deefe77705caf46e60c9f170d23d4719bc4a2ca020",
-        "validated_zero_cue_catalog.json": "8a8b7a4ba97cb22c3aa1f75ab33762052deb09580df464b1eabfe622a2837d26"
-      }
+    "beyond_confirmation_n1025": {
+      "standalone_neural_11class_acc": 92.88,
+      "fair_hybrid_11class_acc": 95.12,
+      "adult_n1016_acc": 98.52,
+      "junk_n977_acc": 99.9,
+      "anime_n636_acc": 98.9,
+      "title_language_n604_acc": 98.51
     },
-    "armiger-audio-guard": {
-      "standalone_repo": "NorviTech/armiger-audio-guard",
-      "files": [
-        "audio_language_guard.py"
-      ],
-      "sha256": {
-        "audio_language_guard.py": "f6f2820d4230faa4f07b9662e1e597c5b893f6855478fceb09b78d2d282ecde2"
-      }
+    "zero_cue_2000_n2000": {
+      "standalone_neural_11class_acc": 87.35,
+      "fair_hybrid_11class_acc": 91.5,
+      "adult_acc": 99.9,
+      "junk_acc": 100.0,
+      "anime_n1998_acc": 95.8,
+      "lang_acc": 88.15,
+      "title_language_acc": 97.75
     },
-    "armiger-calibration-dht": {
-      "standalone_repo": "NorviTech/armiger-calibration-dht",
-      "files": [
-        "calibration.json",
-        "calibration_and_dht.py",
-        "armiger_dht_rsi.py",
-        "test_armiger_dht_rsi.py"
-      ],
-      "sha256": {
-        "calibration.json": "e5b58fc6a8380b982f09296822b0244b28aa5b9b38c32d690c9e25160a8860bb",
-        "calibration_and_dht.py": "b5feaf9e9c5a8304c31675e6c0d4ab14a6ec3fd40bd24bafac109c5b139cbd23",
-        "armiger_dht_rsi.py": "a765952f40c384777af82bb7a7ce4d695e7f9cf12b9487aabb08d7bc3f60c707",
-        "test_armiger_dht_rsi.py": "af765f049fe684aedd5b20cf58e8a0cb8c4cc40fd501e50a78844bcc256ad1c4"
-      }
+    "multilang_3000_n3000": {
+      "standalone_neural_11class_acc": 97.37,
+      "fair_hybrid_11class_acc": 98.4,
+      "adult_acc": 100.0,
+      "junk_acc": 100.0,
+      "anime_n2625_acc": 96.38,
+      "lang_acc": 91.47
     },
-    "armiger-dht-db-sync": {
-      "standalone_repo": "NorviTech/armiger-dht-db-sync",
-      "files": [
-        "csam_guard.py",
-        "armiger_dht_db_sync.py",
-        "test_dht_db_sync.py"
-      ],
-      "sha256": {
-        "csam_guard.py": "fa1fc613034476247587ce8e43044433df38a8092df1210254d7715594ee23b8",
-        "armiger_dht_db_sync.py": "a942043f4aa5887a20b9a1cb5e6632ca248c8dc8d2c905bfaa667f489d751f2d",
-        "test_dht_db_sync.py": "3e3bd272a6adb1e217330c2732a8528cecb46a2d34beaa6b4d7d42518ea22a5d"
-      }
-    }
+    "five_split_summary_n10262": {
+      "weighted_mean_standalone_neural_acc": 93.95,
+      "weighted_mean_fair_hybrid_acc": 95.39,
+      "macro_mean_standalone_neural_acc": 93.42,
+      "macro_mean_fair_hybrid_acc": 95.0
+    },
+    "swarm_liveliness": {
+      "way4_priors_formula_auroc": 86.64,
+      "with_swarm_adapter_public_tracker_n757_auroc": 92.42,
+      "with_swarm_adapter_public_holdout_n493_auroc": 93.03,
+      "with_swarm_adapter_multi_source_corpus_n10278_auroc": 96.83
+    },
+    "overall_6dim_composite_mean": 96.5
   },
-  "sdk": {
-    "entrypoint": "armiger_ultra_pipeline.py",
-    "class_name": "ArmigerUltraPipeline",
-    "test_suite": "test_armiger_ultra_pipeline.py",
-    "unified_heads": [
-      "category",
-      "adult",
-      "junk",
-      "anime",
-      "english_subs",
-      "lang",
-      "owner_scope",
-      "title_language",
-      "swarm_viability",
-      "honeypot_trap",
-      "csam_safety"
-    ],
-    "sha256": {
-      "armiger_ultra_pipeline.py": "5a759dec66b9e13e532240d745afbb38826af90c5a9021c0eb845e6182cd1717",
-      "test_armiger_ultra_pipeline.py": "d4aeaf2143ac192a839e5fc0e14b1b5e03c84434274526dd1f38490d4de59f47"
-    }
+  "hardware_latency_benchmarks": {
+    "apple_m4_pro_cpu_onnx_int8_single_item_p50_ms": 2.44,
+    "apple_m4_pro_cpu_onnx_int8_batch64_per_item_ms": 3.07,
+    "apple_m4_pro_cpu_onnx_int8_batch64_throughput_items_sec": 326.0,
+    "apple_m4_pro_mps_gpu_fp32_batch64_per_item_ms": 0.29,
+    "nvidia_rtx_gpu_fp32_batch64_per_item_ms": 0.21
   },
-  "parameter_count": 8050139
+  "parameter_count": 8050139,
+  "benchmarks": {
+    "heldout_10class_category_acc": 90.94,
+    "beyond_confirmation_category_acc": 90.44,
+    "catalog_matching_rate_acc": 90.34,
+    "audio_language_acc": 98.25,
+    "anime_and_dub_acc": 97.48,
+    "adult_safety_gate_acc": 100.0,
+    "junk_malware_filter_acc": 99.9,
+    "swarm_liveliness_public_auroc": 92.42,
+    "swarm_liveliness_multisource_auroc": 96.83,
+    "fake_seeder_honeypot_recall": 100.0,
+    "overall_6dim_composite_mean": 94.09,
+    "gpu_batched_latency_ms": 0.21,
+    "gpu_single_item_latency_ms": 1.12,
+    "cpu_int8_batched_latency_ms": 0.42
+  }
 }

r13_feature_extractor.py

@@ -0,0 +1,406 @@
+"""R13 S2 features and a read-only adapter for frozen R12 ONNX checkpoints.
+
+There are two feature views. Category keeps the R12 enriched input; title
+language sees the literal title, without file names or file statistics. S8
+should train those views together, rather than transplanting a language head.
+
+Only two semantic rules are admitted: identifier neutrality for the binary
+title-language task, and a bracketed release/episode/technical-tags/video cue
+for anime. ``audit_train_rules`` supplies their train-only precision gates.
+Dual-audio and ASS are observable features, never standalone anime rules.
+"""
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from functools import lru_cache
+import hashlib
+import importlib.util
+import math
+from pathlib import Path
+import re
+from typing import Any, Mapping, Sequence
+
+import numpy as np
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+SIDE_DIM = 28
+BASE_STATS_DIM = 12
+STATS_DIM = 40
+MIN_SUPPORT = 5
+MIN_PRECISION = 0.90
+
+# These are syntax families from the session brief, not title/group catalogs.
+NUMERIC_ID_RE = re.compile(r"[0-9]+(?:-[0-9]+)?", re.ASCII)
+PG_ID_RE = re.compile(r"pg[0-9]+(?:-[0-9]+)?", re.I | re.ASCII)
+GUT_ID_RE = re.compile(r"[a-z0-9_.-]+gut", re.I | re.ASCII)
+PACKAGE_ID_RE = re.compile(r"com(?:\.[a-z][a-z0-9_]*){2,}", re.I | re.ASCII)
+FANSUB_EPISODE_RE = re.compile(
+    r"^\[(?P<group>[^\[\]\r\n]{2,80})\]\s*(?P<title>.+?)\s+-\s+"
+    r"(?P<episode>[0-9]{1,3})(?:v[0-9]+)?\s*"
+    r"(?P<tags>(?:(?:\[[^\[\]\r\n]+\]|\([^()\r\n]+\))\s*)+)"
+    r"\.(?:mkv|mp4|avi|webm)$", re.I,
+)
+RESOLUTION_RE = re.compile(r"\b(?:480|576|720|1080|1440|2160|4320)[pi]\b", re.I)
+JAPANESE_RE = re.compile(r"(?<![a-z])(?:jpn|japanese)(?![a-z])", re.I)
+ENGLISH_RE = re.compile(r"(?<![a-z])(?:eng|english)(?![a-z])", re.I)
+DUAL_AUDIO_RE = re.compile(r"\bdual[ ._-]*audio\b", re.I)
+VIDEO_EXTS = frozenset({"mkv", "mp4", "avi", "webm"})
+RULE_IDENTIFIER = "identifier_title_neutrality"
+RULE_FANSUB = "bracket_episode_resolution_video"
+
+
+@lru_cache(maxsize=1)
+def r12_features():
+    """Load the named local baseline, without importing a trainer or dataset."""
+    path = PROJECT_ROOT / "_r12_features_base.py"
+    spec = importlib.util.spec_from_file_location("_s2_r12_baseline", path)
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Cannot load baseline featurizer: {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    if (module.SIDE_DIM, module.STATS_DIM) != (SIDE_DIM, STATS_DIM):
+        raise ValueError("R12 feature contract changed; requalify S2")
+    return module
+
+
+def normalize_files(files: Any) -> list[dict[str, Any]]:
+    """Support SDK mappings, path/size pairs, and plain relative paths."""
+    result = []
+    for entry in files or []:
+        if isinstance(entry, Mapping):
+            path = entry.get("path") or entry.get("p") or entry.get("name") or ""
+            size = entry.get("size") or entry.get("s") or 0
+        elif isinstance(entry, (tuple, list)):
+            path = entry[0] if entry else ""
+            size = entry[1] if len(entry) > 1 else 0
+        else:
+            path, size = entry, 0
+        try:
+            size = max(0, int(size))
+        except (TypeError, ValueError, OverflowError):
+            size = 0
+        path = str(path or "").replace("\\", "/")
+        if path and "/.____padding_file/" not in f"/{path}":
+            result.append({"path": path, "size": size})
+    return result
+
+
+def _safe_nonneg_int(val: Any) -> int:
+    try:
+        return max(0, int(val or 0))
+    except (TypeError, ValueError, OverflowError):
+        return 0
+
+
+def inference_input(row: Mapping[str, Any]) -> dict[str, Any]:
+    """Use R12's production firewall: name/files/size/infohash, no language hint.
+
+    Matches active_source/armiger_bench.py::sanitize_inference_input for snapshot
+    mappings, while accepting SDK path/size aliases for clean external inputs.
+    """
+    source = row.get("inference_input", row)
+    if not isinstance(source, Mapping):
+        raise TypeError("inference_input must be a mapping")
+    return {"name": str(source.get("name") or source.get("title") or ""),
+            "files": normalize_files(source.get("files")),
+            "size": _safe_nonneg_int(source.get("size")),
+            "infohash": str(source.get("infohash") or "").lower()}
+
+
+def _utf8_prefix(text: str, max_bytes: int) -> str:
+    if max_bytes < 1:
+        raise ValueError("max_bytes must be positive")
+    return str(text).encode("utf-8", "replace")[:max_bytes].decode("utf-8", "ignore")
+
+
+def build_title_language_text(name: str, files: Any = None, max_bytes: int = 256) -> str:
+    """Title-only view. Files deliberately have no effect on this representation."""
+    return _utf8_prefix(name, max_bytes)
+
+
+def build_enriched_name_text(
+    name: str, files: Any, max_bytes: int = 256, *, head: str = "category",
+) -> str:
+    """Keep R12 enrichment for category; expose a separate title-language view."""
+    if head == "title_language":
+        return build_title_language_text(name, max_bytes=max_bytes)
+    text = r12_features().build_enriched_name_text(name, normalize_files(files), max_bytes=max_bytes)
+    return _utf8_prefix(text, max_bytes)
+
+
+def _id_stem(name: str) -> str:
+    stem = name.strip()
+    # Exact opaque file identifiers are also supported, but not arbitrary paths.
+    if stem.lower().endswith((".txt", ".zip")):
+        stem = stem.rsplit(".", 1)[0]
+    return stem
+
+
+def identifier_family(name: str, files: Any = None) -> str | None:
+    """Return a nonlinguistic-ID family, never infer a work or spoken language."""
+    stem = _id_stem(name)
+    for family, pattern in (("numeric", NUMERIC_ID_RE), ("pg_numeric", PG_ID_RE),
+                            ("gut_stem", GUT_ID_RE), ("ascii_package", PACKAGE_ID_RE)):
+        if pattern.fullmatch(stem):
+            return family
+    # TXT+ZIP alone is not enough: require an opaque Gutenberg-shaped stem
+    # and exactly matching relative path, rather than unrelated archive files.
+    by_ext: dict[str, set[str]] = {"txt": set(), "zip": set()}
+    for item in normalize_files(files):
+        path = item["path"].lower()
+        base, dot, ext = path.rpartition(".")
+        if dot and ext in by_ext:
+            leaf = base.rsplit("/", 1)[-1]
+            if NUMERIC_ID_RE.fullmatch(leaf) or PG_ID_RE.fullmatch(leaf):
+                by_ext[ext].add(base)
+    # A readable supplied title must retain its own language, even with book files.
+    opaque_name = not re.search(r"[a-z]{3,}", name, re.I | re.ASCII)
+    if opaque_name and by_ext["txt"] & by_ext["zip"]:
+        return "gutenberg_txt_zip"
+    return None
+
+
+@dataclass(frozen=True)
+class StructuralCues:
+    fansub_episode_keys: frozenset[int]
+    fansub_video_count: int
+    has_mkv: bool
+    has_ass_subtitles: bool
+    explicit_jpn_eng_dual_audio: bool
+
+    @property
+    def fansub_episode(self) -> bool:
+        return bool(self.fansub_episode_keys)
+
+
+def extract_structural_cues(name: str, files: Any = None) -> StructuralCues:
+    """Parse arbitrary group tags; there are no release-group or work literals."""
+    entries = normalize_files(files)
+    texts = [name, *(f["path"].rsplit("/", 1)[-1] for f in entries)]
+    episodes: set[int] = set()
+    matched: set[str] = set()
+    for text in texts:
+        match = FANSUB_EPISODE_RE.fullmatch(text)
+        if match and RESOLUTION_RE.search(match["tags"]):
+            episodes.add(int(match["episode"]))
+            matched.add(text)
+    exts = {t.rsplit(".", 1)[-1].lower() for t in texts if "." in t}
+    # These fields describe metadata only. They do not assert anime/sub language.
+    audio_text = " ".join(texts)
+    dual = bool(DUAL_AUDIO_RE.search(audio_text) and JAPANESE_RE.search(audio_text)
+                and ENGLISH_RE.search(audio_text) and "mkv" in exts)
+    return StructuralCues(frozenset(episodes), len(matched), "mkv" in exts, "ass" in exts, dual)
+
+
+def compute_derivative_group_features(files: Any, raw_name: str = "") -> tuple[float, ...]:
+    """R12 U/P/share semantics plus explicit bracketed episode/version parsing.
+
+    Episode numbers in SxxExx and fansub paths refer to the same episodes: use
+    the larger count rather than summing two parsers' possibly duplicate keys.
+    S8 receives raw counts as well as the bounded side-vector representation.
+    """
+    normalized = normalize_files(files)
+    if not normalized and raw_name.rsplit(".", 1)[-1].lower() in VIDEO_EXTS:
+        normalized = [{"path": raw_name, "size": 0}]
+    # The derivative view drops resolution/version tags only after a full
+    # structural match. Keep parent+title+episode, so separate episodes/series
+    # cannot collapse merely because their codec, group, or episode number agrees.
+    derivative_view = []
+    for entry in normalized:
+        parent, sep, leaf = entry["path"].rpartition("/")
+        match = FANSUB_EPISODE_RE.fullmatch(leaf)
+        if match and RESOLUTION_RE.search(match["tags"]):
+            ext = leaf.rsplit(".", 1)[-1]
+            leaf = f"{match['title']}.E{int(match['episode']):03d}.{ext}"
+            derivative_view.append({"path": parent + sep + leaf, "size": entry["size"]})
+        else:
+            derivative_view.append(entry)
+    u, e, p, share = r12_features().compute_derivative_group_features(derivative_view, raw_name)
+    fan_count = len(extract_structural_cues(raw_name, normalized).fansub_episode_keys)
+    e = max(e, float(fan_count))
+    return u, e, (0.0 if e >= 2 else p), share
+
+
+def encode_torrent_features(row: Mapping[str, Any], max_name_len: int = 256,
+                            max_files: int = 64) -> dict[str, Any]:
+    """S8 training/inference encoder. R12 checkpoints use the adapter below.
+
+    New keys: title_name_bytes, title_name_text, title_identifier_family,
+    structural_cues. Existing stats remain 40 wide. side[13]/side[15] gain
+    subtitle presence and a validated generic fansub cue. side[24:28] preserve
+    their U/E/P/share meaning; no new checkpoint width is silently introduced.
+    """
+    clean = inference_input(row)
+    name = str(clean.get("name") or clean.get("title") or "")
+    encoded = r12_features().encode_torrent_features(clean, max_name_len, max_files)
+    cues = extract_structural_cues(name, clean["files"])
+    deriv = compute_derivative_group_features(clean["files"], name)
+    stats = list(encoded["stats"])
+    if cues.fansub_episode:
+        stats[BASE_STATS_DIM + 15] = 1.0
+    if cues.has_ass_subtitles:
+        stats[BASE_STATS_DIM + 13] = 1.0
+    u, e, p, share = deriv
+    stats[BASE_STATS_DIM + 24:] = [min(1.0, math.log1p(u) / math.log1p(64)),
+                                  min(1.0, math.log1p(e) / math.log1p(64)), p, share]
+    title = build_title_language_text(name, max_bytes=max_name_len)
+    encoded.update(stats=stats, deriv_features=deriv, structural_cues=cues,
+                   title_name_text=title, title_name_bytes=list(title.encode("utf-8")) or [32],
+                   title_identifier_family=identifier_family(name, clean["files"]))
+    return encoded
+
+
+def build_title_language_batch_inputs(rows: Sequence[Mapping[str, Any]],
+                                      stats_dim: int = STATS_DIM) -> dict[str, np.ndarray]:
+    """A fully separate name view: no file bytes, sizes, metadata, or language hint.
+
+    Directly replacing bytes avoids R12's file fallback for dotted names. All
+    non-title tensors have the same constant value for every title.
+    """
+    names = [str((r := inference_input(row)).get("name") or r.get("title") or "") for row in rows]
+    data = [list(build_title_language_text(n).encode("utf-8")) or [32] for n in names]
+    batch = len(data)
+    if batch == 0:
+        raise ValueError("rows must not be empty")
+    name_bytes = np.zeros((batch, max(map(len, data))), dtype=np.int64)
+    for i, values in enumerate(data):
+        name_bytes[i, :len(values)] = values
+    return {"name_bytes": name_bytes, "name_len": np.asarray(list(map(len, data)), dtype=np.int64),
+            "ext": np.zeros((batch, 1), dtype=np.int32),
+            "size": np.zeros((batch, 1), dtype=np.int64),
+            "depth": np.zeros((batch, 1), dtype=np.int64),
+            "words": np.zeros((batch, 1, 4), dtype=np.int32),
+            "stats": np.zeros((batch, stats_dim), dtype=np.float32)}
+
+
+def _label(row: Mapping[str, Any], head: str) -> str | None:
+    target = (row.get("targets") or {}).get(head) or {}
+    return target.get("value") if target.get("known_mask") else None
+
+
+def audit_train_rules(rows: Sequence[Mapping[str, Any]]) -> dict[str, Any]:
+    """Freeze support using train labels only; unknown masks never count as gold.
+
+    The identifier rule is one pre-specified union from the user's brief.
+    Subgroup counts are retained so absent supervision is explicit.
+    """
+    counts = {RULE_IDENTIFIER: Counter(), RULE_FANSUB: Counter()}
+    subgroups: dict[str, Counter] = {}
+    for row in rows:
+        if row.get("split") != "train":
+            raise ValueError("Rule admission accepts train-marked rows only")
+        clean = inference_input(row)
+        name = str(clean.get("name") or clean.get("title") or "")
+        family = identifier_family(name, clean["files"])
+        if family:
+            value = _label(row, "title_language") or "unknown"
+            counts[RULE_IDENTIFIER][value] += 1
+            subgroups.setdefault(family, Counter())[value] += 1
+        if extract_structural_cues(name, clean["files"]).fansub_episode:
+            counts[RULE_FANSUB][_label(row, "anime") or "unknown"] += 1
+    report: dict[str, Any] = {}
+    for rule, positive in ((RULE_IDENTIFIER, "english_title"), (RULE_FANSUB, "anime")):
+        c = counts[rule]
+        support = sum(v for k, v in c.items() if k != "unknown")
+        precision = c[positive] / support if support else 0.0
+        report[rule] = {"counts": dict(c), "known_support": support, "precision": precision,
+                        "admitted": support >= MIN_SUPPORT and precision >= MIN_PRECISION}
+    report["identifier_subgroups"] = {k: dict(v) for k, v in subgroups.items()}
+    report["dual_audio_ass_standalone_rule_admitted"] = False
+    return report
+
+
+def apply_head_guards(row: Mapping[str, Any], predictions: Mapping[str, str],
+                      train_audit: Mapping[str, Any], *,
+                      enable_identifier_guard: bool = False) -> tuple[dict[str, str], dict[str, str]]:
+    """Copy predictions, modify only title_language/anime, and expose provenance.
+
+    english_title is the existing binary task's compatibility value for an
+    identifier without a readable title. It is not an assertion about book text,
+    spoken language, subtitle language, country, or the title behind an ID.
+    """
+    clean = inference_input(row)
+    name = str(clean.get("name") or clean.get("title") or "")
+    result, reasons = dict(predictions), {}
+    family = identifier_family(name, clean["files"])
+    if (enable_identifier_guard and family
+            and train_audit.get(RULE_IDENTIFIER, {}).get("admitted")):
+        result["title_language"] = "english_title"
+        reasons["title_language"] = f"{RULE_IDENTIFIER}:{family}"
+    if (extract_structural_cues(name, clean["files"]).fansub_episode
+            and train_audit.get(RULE_FANSUB, {}).get("admitted")):
+        result["anime"] = "anime"
+        reasons["anime"] = RULE_FANSUB
+    return result, reasons
+
+
+class R13FrozenR12Adapter:
+    """Head-local compatibility probe, never writes/changes model weights.
+
+    Category and all unrelated heads come from the original R12 feature feed.
+    Title-only inference is used for opaque IDs or names R12 enriched; ordinary
+    titles retain the frozen model's trained feature distribution. S8 can use
+    title_name_bytes for every row during native joint training.
+
+    Blanket identifier neutrality is an opt-in compatibility candidate: it
+    passes the pooled train gate but regresses known validation titles. Always
+    expose its ablation separately; the safe default uses title-only inference.
+    """
+    def __init__(self, model_path: str | Path, train_audit: Mapping[str, Any], threads: int = 2,
+                 *, enable_identifier_guard: bool = False):
+        import onnxruntime as ort
+        options = ort.SessionOptions()
+        options.intra_op_num_threads = threads
+        options.inter_op_num_threads = 1
+        self.session = ort.InferenceSession(str(model_path), sess_options=options,
+                                            providers=["CPUExecutionProvider"])
+        self.stats_dim = next(i.shape[1] for i in self.session.get_inputs() if i.name == "stats")
+        self.train_audit = train_audit
+        self.enable_identifier_guard = enable_identifier_guard
+
+    def predict_batch(self, rows: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]:
+        if not rows:
+            return []
+        baseline = r12_features()
+        clean = [inference_input(r) for r in rows]
+        head_names = [o.name for o in self.session.get_outputs()
+                      if o.name in baseline.NEURAL_HEAD_CLASSES and len(o.shape) == 2]
+        feed = baseline.build_onnx_batch_inputs(clean, stats_dim=self.stats_dim)
+        logits = dict(zip(head_names, self.session.run(head_names, feed)))
+        routed = []
+        for i, row in enumerate(clean):
+            name = str(row.get("name") or row.get("title") or "")
+            if (identifier_family(name, row["files"])
+                    or baseline.build_enriched_name_text(name, row["files"]) != name):
+                routed.append(i)
+        title_logits = None
+        if routed:
+            title_feed = build_title_language_batch_inputs([clean[i] for i in routed], self.stats_dim)
+            title_logits = self.session.run(["title_language"], title_feed)[0]
+        route_index = {index: j for j, index in enumerate(routed)}
+        result = []
+        for i, row in enumerate(clean):
+            raw = {h: baseline.NEURAL_HEAD_CLASSES[h][int(np.argmax(values[i]))]
+                   for h, values in logits.items()}
+            view = dict(raw)
+            if i in route_index:
+                view["title_language"] = baseline.NEURAL_HEAD_CLASSES["title_language"][
+                    int(np.argmax(title_logits[route_index[i]]))]
+            guarded, reasons = apply_head_guards(row, view, self.train_audit,
+                                                 enable_identifier_guard=self.enable_identifier_guard)
+            candidate, candidate_reasons = apply_head_guards(row, view, self.train_audit,
+                                                            enable_identifier_guard=True)
+            result.append({"baseline": raw, "title_only": view, "predictions": guarded,
+                           "guard_reasons": reasons, "title_view_routed": i in route_index,
+                           "identifier_policy_candidate": candidate,
+                           "identifier_policy_guard_reasons": candidate_reasons})
+        return result
+
+
+def sha256_file(path: str | Path) -> str:
+    digest = hashlib.sha256()
+    with Path(path).open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()

r13_features.py

@@ -0,0 +1,66 @@
+"""Explicit R13 tensor ABI: 40 S2 features plus raw title byte length.
+
+The last scalar is a mask boundary, never a learned feature. Both views share
+the transformer; the title head cannot attend to appended file names.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+try:
+    from . import r13_feature_extractor as s2
+except ImportError:
+    try:
+        import r13_feature_extractor as s2
+    except ImportError:
+        from r13_master_program.s2_neural_features import r13_feature_extractor as s2
+
+BASE_STATS_DIM, SIDE_DIM, STATS_DIM = 12, 28, 41
+INPUTS = ("name_bytes", "name_len", "ext", "size", "depth", "words", "stats")
+
+
+def encode_torrent_features(row, max_name_len=256, max_files=64):
+    encoded = s2.encode_torrent_features(row, max_name_len, max_files)
+    title = encoded["title_name_bytes"]
+    # S2's enriched representation starts with the supplied title. Empty titles
+    # have a stable space token rather than consuming any file-derived byte.
+    if not str(
+        s2.inference_input(row).get("name")
+        or s2.inference_input(row).get("title")
+        or ""
+    ):
+        encoded["name_bytes"] = [32]
+    if encoded["name_bytes"][: len(title)] != title:
+        raise ValueError("Enriched input no longer preserves the raw title prefix")
+    encoded["stats"] = list(encoded["stats"]) + [float(len(title))]
+    return encoded
+
+
+def build_onnx_batch_inputs(rows, max_name_len=256, max_files=64, stats_dim=STATS_DIM):
+    if isinstance(stats_dim, bool) or not isinstance(stats_dim, (int, np.integer)) or stats_dim != STATS_DIM:
+        raise ValueError("R13 requires exactly 41 stats components; padding or truncation changes its feature ABI")
+    if not rows:
+        raise ValueError("Cannot collate an empty batch")
+    enc = [encode_torrent_features(r, max_name_len, max_files) for r in rows]
+    b, length, files = (
+        len(enc),
+        max(len(e["name_bytes"]) for e in enc),
+        max(1, max(len(e["ext"]) for e in enc)),
+    )
+    out = {
+        "name_bytes": np.zeros((b, length), np.int64),
+        "name_len": np.zeros(b, np.int64),
+        "ext": np.zeros((b, files), np.int32),
+        "size": np.zeros((b, files), np.int64),
+        "depth": np.zeros((b, files), np.int64),
+        "words": np.zeros((b, files, 4), np.int32),
+        "stats": np.zeros((b, stats_dim), np.float32),
+    }
+    for i, e in enumerate(enc):
+        n, f = len(e["name_bytes"]), len(e["ext"])
+        out["name_bytes"][i, :n], out["name_len"][i] = e["name_bytes"], n
+        for k in ("ext", "size", "depth", "words"):
+            out[k][i, :f] = e[k]
+        out["stats"][i] = e["stats"]
+    return out