Release Armiger v3.4.0 (v3.0-gold-r13.4) model weights, seq=9 BEP-46 torrents, and updated evaluation charts

README.md

@@ -21,18 +21,18 @@ tags:
   - cpu-inference
 ---
 
-# Armiger `v3.3.0` — INT8 ONNX CPU Classifier
+# Armiger `v3.4.0` — INT8 ONNX CPU Classifier
 
-**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
+**Release:** [`v3.4.0`](https://github.com/spencernorton/armiger/releases/tag/v3.4.0) · **Artifact:** `17.6 MB` INT8 ONNX (`armiger.int8.onnx` / `armiger.onnx`) · **Parameters:** `8.05M` · **License:** Apache-2.0
 
 **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).
 
-![Armiger v3.3.0 Overview](assets/armiger_overview.png)
+![Armiger v3.4.0 Overview](assets/armiger_overview.png)
 
 ## Quickstart
 
 ```bash
-python -m pip install "armiger @ git+https://github.com/spencernorton/armiger.git@v3.3.0"
+python -m pip install "armiger @ git+https://github.com/spencernorton/armiger.git@v3.4.0"
 python -m armiger download --directory ./models-cpu --variant cpu
 ```
 
@@ -55,6 +55,6 @@ print(res["heads"]["category"], res["matching_identity"], res["mondrian_gates"][
 ## Links & Ecosystem
 
 - **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`)
+- **Core Package, Containers & Evaluation (`v3.4.0`):** [`spencernorton/armiger`](https://github.com/spencernorton/armiger) (`ghcr.io/spencernorton/armiger-ultra:3.4.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)

armiger.int8.onnx

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

armiger.onnx

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

byte_span_extractor.py

@@ -16,6 +16,7 @@ Provides four explicitly separated extraction and decoding modes for scientific
 """
 from __future__ import annotations
 
+import bisect
 import math
 import re
 import unicodedata
@@ -156,6 +157,12 @@ def snap_bio_span_boundaries(
                         ns += 1
                     while ne > ns and b_raw[ne - 1] in SEP_BYTES:
                         ne -= 1
+                    if b_tag == BIO_B_TITLE and ne > ns:
+                        m_suf = re.search(rb"(?i)(?:\d{3,6}gut|(?:_\d{4})?_librivox)$", bytes(b_raw[ns:ne]))
+                        if m_suf and m_suf.start() >= 2:
+                            ne = ns + m_suf.start()
+                            while ne > ns and b_raw[ne - 1] in SEP_BYTES:
+                                ne -= 1
                     if ne - ns >= min_len:
                         arr_list[ns] = b_tag
                         for k in range(ns + 1, ne):
@@ -231,7 +238,12 @@ def snap_bio_span_boundaries(
                 while ns > 0 and b_raw[ns - 1] not in SEP_BYTES and arr_list[ns - 1] == BIO_O:
                     ns -= 1
                 while ne < L and b_raw[ne] not in SEP_BYTES and arr_list[ne] in (BIO_O, BIO_I_TITLE):
+                    if arr_list[ne] == BIO_O and (48 <= b_raw[ne] <= 57):
+                        break
                     ne += 1
+                m_suf = re.search(rb"(?i)(?:\d{3,6}gut|(?:_\d{4})?_librivox)$", bytes(b_raw[ns:ne]))
+                if m_suf and m_suf.start() >= 2:
+                    ne = ns + m_suf.start()
                 while ns < ne and b_raw[ns] in SEP_BYTES:
                     ns += 1
                 while ne > ns and b_raw[ne - 1] in SEP_BYTES:
@@ -351,13 +363,21 @@ LEADING_SITE_RE = re.compile(
     r"(?i)^(?:www\.[a-z0-9\-]+\.[a-z]{2,6}[\s\._\-]+|\[?[a-z0-9\-]+\.(?:com|org|net|to|me|cc|pe|mx|ro|lol|tv|ru|in)\]?[\s\._\-\|]+)+"
 )
 
+_NEXT_TECH_RE = (
+    r"(?=[\.\s_\-\)\]\}]*(?:2160p|1080p|1080i|720p|576p|480p|360p|4k|uhd|bluray|blu-ray|"
+    r"bdrip|brrip|remux|web-dl|webdl|webrip|hdtv|dvdrip|hdrip|dvdr|dvd9|dvd5|x264|x265|h264|h265|"
+    r"h\.264|h\.265|hevc|avc|av1|xvid|divx|10bit|8bit|aac|ddp|eac3|ac3|dts|truehd|atmos|flac|mp3|"
+    r"opus|repack|rerip|audio|lat|sub|subs)\b)"
+)
+
 BOUNDARY_RE = re.compile(
     r"(?i)(?:"
     r"[\.\s_\-\(\[\{]+(?:19[2-9]\d|20[0-2]\d)(?:[\.\s_\-\)\]\}]|$)"
     r"|[\.\s_\-\(\[\{]+(?:S\d{1,2}[\.\s_\-]*-[\.\s_\-]*S?\d{1,2}|S\d{1,2}(?:E\d{1,3})?|\d{1,2}x\d{2}|Season[\.\s_\-]*\d+|Complete[\.\s_\-]+Series|Mini[\.\s_\-]*Series|E\d{2,3}\b|Ep\.?\s*\d{1,4}\b|Episode[\.\s_\-]*\d{1,4}\b|Cap\.\d{2,4}\b|Temporada[\.\s_\-]*\d+)"
     r"|[\.\s_\-]+-\s*(?:0\d|[1-9]\d{0,2})(?:v\d)?(?:[\.\s_\-\[\(]|$)"
     r"|[\.\s_\-\(\[\{]+v\d+\.\d+(?:\.\d+)?\b"
-    r"|[\.\s_\-\(\[\{]+(?:2160p|1080p|1080i|720p|576p|480p|4k|uhd|bluray|blu-ray|bdrip|brrip|remux|web-dl|webdl|webrip|hdtv|dvdrip|hdrip|dvdr|dvd9|dvd5|x264|x265|h264|h265|h\.264|h\.265|hevc|av1|xvid|divx|proper|repack|rerip|extended|unrated|directors[\.\s_\-]*cut|remastered|multi|dual[\.\s_\-]*audio|dual[\.\s_\-]*lat|truefrench|vff|vfq|vfi|vostfr|sub[\.\s_\-]*ita|ita[\.\s_\-]*eng)\b"
+    r"|[\.\s_\-\(\[\{]+(?:2160p|1080p|1080i|720p|576p|480p|4k|uhd|bluray|blu-ray|bdrip|brrip|remux|web[\s._-]*(?:dl|rip|hd|cap)|hdtv|dvdrip|hdrip|dvdr|dvd9|dvd5|x264|x265|h264|h265|h\.264|h\.265|hevc|avc|av1|xvid|divx|10bit|8bit|hdr10\+?|aac\d*(?:\.\d+)?|ddp?\d*(?:\.\d+)?|eac3|ac3|dts(?:-?hd)?|truehd|atmos|repack|rerip|extended|unrated|directors[\.\s_\-]*cut|remastered|dual[\.\s_\-]*audio|dual[\.\s_\-]*lat|truefrench|vff|vfq|vfi|vostfr|sub[\.\s_\-]*ita|ita[\.\s_\-]*eng)(?![a-z0-9])"
+    r"|[\.\s_\-\(\[\{]+(?:web|proper|internal|limited|multi|dual)\b" + _NEXT_TECH_RE +
     r"|[\.\s_\-\(\[\{]+(?:rus|russian|castellano|latino|german|french|italian|spanish|hindi|korean|japanese|chinese)\b(?=[\.\s_\-\)\]\}]*(?:2160p|1080p|1080i|720p|576p|480p|4k|uhd|bluray|blu-ray|bdrip|brrip|remux|web-dl|webdl|webrip|web|hdtv|dvdrip|hdrip|dvdr|dvd9|dvd5|x264|x265|h264|h265|h\.264|h\.265|hevc|av1|xvid|divx|aac|ac3|eac3|ddp\d*(?:\.\d)?|dts(?:-?hd)?|truehd|atmos|flac|mp3|m4b|dl|dub|dubbed|sub|subbed|subs|vostfr|multi|dual|audio|proper|repack|rerip|internal|limited|complete)\b)"
     r"|\s*[\[\(\{](?:1080p|720p|2160p|480p|BD|WEB|BDRip|BluRay|HEVC|x264|x265|Dual|Multi|ENG|ITA|RUS|SPA|FRE|GER|Sub|AAC|AC3|DTS|FLAC)[^\)\]\}]*[\]\)\}]"
     r")"
@@ -378,11 +398,27 @@ TRAILING_JUNK_RE = re.compile(
 )
 TECH_TOKEN_SET = frozenset({
     "1080p", "1080i", "720p", "2160p", "480p", "576p", "4k", "uhd", "sdr", "hdr", "hdr10", "dv",
-    "web", "webdl", "webrip", "bluray", "bdrip", "brrip", "remux", "hdtv", "dvdrip", "hdrip", "dvdr",
+    "webdl", "webrip", "bluray", "bdrip", "brrip", "remux", "hdtv", "dvdrip", "hdrip", "dvdr",
     "x264", "x265", "h264", "h265", "hevc", "avc", "xvid", "divx", "av1", "10bit", "8bit",
     "aac", "ac3", "eac3", "ddp", "ddp5", "dts", "dtshd", "truehd", "atmos", "flac", "mp3", "opus",
-    "mkv", "mp4", "avi", "proper", "repack", "rerip", "internal", "limited", "multi", "dual",
+    "mkv", "mp4", "avi", "repack", "rerip",
 })
+TOKEN_HYGIENE_RE = re.compile(
+    r"(?i)(?<![a-z0-9])(?:2160p|1080p|1080i|720p|576p|480p|360p|4k|uhd|sdr|hdr10\+?|hdr|dv|"
+    r"web[\s._-]*(?:dl|rip|hd|cap)|bluray|blu-ray|bdrip|brrip|remux|hdtv|dvdrip|hdrip|dvdr|dvd9|dvd5|"
+    r"x264|x265|h264|h265|h\.264|h\.265|hevc|avc|av1|xvid|divx|10bit|8bit|"
+    r"aac\d*(?:\.\d+)?|ddp?\d*(?:\.\d+)?|eac3|ac3|dts(?:-?hd)?|truehd|atmos|flac|mp3|opus|"
+    r"mkv|mp4|avi|repack|rerip|"
+    r"(?:web|proper|internal|limited|multi|dual)" + _NEXT_TECH_RE + r")(?![a-z0-9])"
+)
+
+
+def _hygiene_title_end(text: str) -> int:
+    match = TOKEN_HYGIENE_RE.search(text)
+    end = match.start() if match else len(text)
+    while end > 0 and text[end - 1] in " ._-([{|:/":
+        end -= 1
+    return end
 
 
 def key_norm(s: str) -> str:
@@ -446,10 +482,79 @@ def _utf8_safe_window(raw_name: str, max_bytes: int = 256) -> tuple[str, bytes,
     return win_str, win_str.encode("utf-8"), True
 
 
+RES_SPAN_RE = re.compile(
+    r"(?i)(?<![0-9a-z])(2160p|1080p|1080i|720p|576p|480p|360p|4k|uhd)(?![0-9a-z])"
+)
+
+
+def build_char_to_byte_offsets(s: str) -> list[int]:
+    """Explicit char-index -> UTF-8 byte-offset table with `len(s) + 1` entries.
+
+    `offsets[i]` is the byte offset at which character `i` starts and
+    `offsets[-1] == len(s.encode('utf-8'))`. Regex character spans must be
+    converted through this table (R12 Session 2): indexing bytes sliced with
+    `s.encode('utf-8')[:64]` by character offsets misaligns every multi-byte
+    (Japanese / French / German / Cyrillic) torrent name.
+    """
+    offsets = [0]
+    total = 0
+    for ch in s or "":
+        total += len(ch.encode("utf-8", errors="replace"))
+        offsets.append(total)
+    return offsets
+
+
+def _offsets_char_to_byte_span(
+    offsets: list[int], c_start: int, c_end: int, max_bytes: int = 256
+) -> tuple[int, int]:
+    n = len(offsets) - 1
+    cs = min(max(int(c_start), 0), n)
+    ce = min(max(int(c_end), 0), n)
+    return min(offsets[cs], max_bytes), min(offsets[ce], max_bytes)
+
+
+def _offsets_byte_to_char_span(offsets: list[int], b_start: int, b_end: int) -> tuple[int, int]:
+    """Map a byte span back to the covering char span (mid-char edges snap outward)."""
+    cs = bisect.bisect_right(offsets, max(int(b_start), 0)) - 1
+    ce = bisect.bisect_left(offsets, max(int(b_end), 0))
+    n = len(offsets) - 1
+    return min(max(cs, 0), n), min(max(ce, 0), n)
+
+
 def _char_to_byte_span(s: str, c_start: int, c_end: int, max_bytes: int = 256) -> tuple[int, int]:
-    b_start = len(s[:max(0, c_start)].encode("utf-8", errors="replace"))
-    b_end = len(s[:max(0, c_end)].encode("utf-8", errors="replace"))
-    return min(b_start, max_bytes), min(b_end, max_bytes)
+    return _offsets_char_to_byte_span(build_char_to_byte_offsets(s), c_start, c_end, max_bytes)
+
+
+def _with_span_aliases(res: dict[str, Any], raw_name: str) -> dict[str, Any]:
+    """Guarantee the full char/byte span key contract on any extractor result.
+
+    R11 Stage-3A `ws2_catalog_and_bio.py` crashed with
+    `KeyError: 'title_span_bytes'` because only `title_byte_span` existed.
+    Every public result now always carries `title_span` (chars),
+    `title_span_bytes` (UTF-8 bytes), `year_span`, `res_span` and their
+    `*_bytes` / legacy `*_byte_span` counterparts (values `None` when absent).
+    """
+    nm = raw_name or ""
+    offsets = build_char_to_byte_offsets(nm)
+    out = dict(res)
+
+    def _fill(byte_key: str, bytes_alias: str, char_key: str) -> None:
+        bspan = out.get(bytes_alias, out.get(byte_key))
+        if bspan is not None:
+            bspan = (int(bspan[0]), int(bspan[1]))
+        out.setdefault(byte_key, bspan)
+        out.setdefault(bytes_alias, bspan)
+        if out.get(char_key) is None and bspan is not None:
+            out[char_key] = _offsets_byte_to_char_span(offsets, bspan[0], bspan[1])
+
+    if out.get("title_byte_span") is None and out.get("title_span_bytes") is None:
+        out["title_byte_span"] = (0, 0)
+    _fill("title_byte_span", "title_span_bytes", "title_span")
+    _fill("year_byte_span", "year_span_bytes", "year_span")
+    _fill("episode_byte_span", "episode_span_bytes", "episode_span")
+    _fill("res_byte_span", "res_span_bytes", "res_span")
+    out.setdefault("res", None)
+    return out
 
 
 def extract_byte_spans_v3(raw_name: str, max_bytes: int = 256) -> dict[str, Any]:
@@ -490,6 +595,7 @@ def extract_byte_spans_v3(raw_name: str, max_bytes: int = 256) -> dict[str, Any]
         c_end = c_start + m_junk.start()
         while c_end > c_start and work[c_end - 1] in " ._-([{|:/":
             c_end -= 1
+    c_end = c_start + _hygiene_title_end(work[c_start:c_end])
     base_c_start = c_start
     token_spans = list(re.finditer(r"[^\._\s]+", work[base_c_start:c_end]))
     while len(token_spans) > 1 and key_norm(token_spans[-1].group(0)) in TECH_TOKEN_SET:
@@ -541,37 +647,67 @@ def extract_byte_spans_v3(raw_name: str, max_bytes: int = 256) -> dict[str, Any]
             clean_title = ""
             c_start, c_end = 0, 0
 
-    t_bstart, t_bend = _char_to_byte_span(nm, c_start, c_end, max_bytes=max_bytes)
+    # R12: convert every regex char span through ONE explicit char->byte
+    # offset table built on the window string. Char spans always index `nm`;
+    # byte spans always index `nm.encode('utf-8')` (clipped to `max_bytes`).
+    offsets = build_char_to_byte_offsets(nm)
+    t_bstart, t_bend = _offsets_char_to_byte_span(offsets, c_start, c_end, max_bytes)
     if not clean_title or t_bstart >= t_bend:
         clean_title = ""
         t_bstart, t_bend = 0, 0
+        c_start, c_end = 0, 0
 
     year_val = None
     year_bspan = None
+    year_cspan = None
     ym = YEAR_SPAN_RE.search(nm, pos=max(0, c_end - 1)) or YEAR_SPAN_RE.search(nm)
     if ym:
-        yb_s, yb_e = _char_to_byte_span(nm, ym.start(1), ym.end(1), max_bytes=max_bytes)
+        yb_s, yb_e = _offsets_char_to_byte_span(offsets, ym.start(1), ym.end(1), max_bytes)
         if yb_e - yb_s == 4:
             year_val = int(ym.group(1))
             year_bspan = (yb_s, yb_e)
+            year_cspan = (ym.start(1), ym.end(1))
 
     ep_val = None
     ep_bspan = None
+    ep_cspan = None
     em = EPISODE_SPAN_RE.search(nm, pos=max(0, c_end - 1)) or EPISODE_SPAN_RE.search(nm)
     if em:
-        eb_s, eb_e = _char_to_byte_span(nm, em.start(1), em.end(1), max_bytes=max_bytes)
+        eb_s, eb_e = _offsets_char_to_byte_span(offsets, em.start(1), em.end(1), max_bytes)
         if eb_s < eb_e:
             ep_val = em.group(1).strip()
             ep_bspan = (eb_s, eb_e)
+            ep_cspan = (em.start(1), em.end(1))
+
+    res_val = None
+    res_bspan = None
+    res_cspan = None
+    rm = RES_SPAN_RE.search(nm)
+    if rm:
+        rb_s, rb_e = _offsets_char_to_byte_span(offsets, rm.start(1), rm.end(1), max_bytes)
+        if rb_s < rb_e:
+            res_val = rm.group(1)
+            res_bspan = (rb_s, rb_e)
+            res_cspan = (rm.start(1), rm.end(1))
 
     anchored = bool(clean_title and t_bstart < t_bend and is_strict_clean_title(clean_title, nm))
     return {
         "title": clean_title,
         "title_byte_span": (t_bstart, t_bend),
+        "title_span_bytes": (t_bstart, t_bend),
+        "title_span": (c_start, c_end),
         "year": year_val,
         "year_byte_span": year_bspan,
+        "year_span_bytes": year_bspan,
+        "year_span": year_cspan,
         "episode_spec": ep_val,
         "episode_byte_span": ep_bspan,
+        "episode_span_bytes": ep_bspan,
+        "episode_span": ep_cspan,
+        "res": res_val,
+        "res_byte_span": res_bspan,
+        "res_span_bytes": res_bspan,
+        "res_span": res_cspan,
         "is_anchored": anchored,
         "extractor_source": "structural_byte_span",
     }
@@ -629,8 +765,14 @@ def decode_bio_tags_raw_neural(raw_name: str, bio_tags: Sequence[int] | Any) ->
         runs.append((run_s, prev + 1))
         tb, te = max(runs, key=lambda r: r[1] - r[0])
         cand_raw = raw_bytes[tb:te].decode("utf-8", errors="replace")
+        if TOKEN_HYGIENE_RE.search(cand_raw):
+            cand_end = _hygiene_title_end(cand_raw)
+            te = tb + len(cand_raw[:cand_end].encode("utf-8"))
+            cand_raw = cand_raw[:cand_end]
         words = re.sub(r"[\._]+", " ", cand_raw).strip(" ._-[({/|:").split()
         clean_title = " ".join(words).strip()
+        if not clean_title:
+            tb, te = 0, 0
     else:
         tb, te = 0, 0
         clean_title = ""
@@ -670,20 +812,32 @@ def decode_bio_tags_raw_neural(raw_name: str, bio_tags: Sequence[int] | Any) ->
                 if es >= te:
                     break
 
-    return {
-        "title": clean_title,
-        "title_byte_span": (tb, te),
-        "year": year_val,
-        "year_byte_span": year_bspan,
-        "episode_spec": ep_val,
-        "episode_byte_span": ep_bspan,
-        "is_anchored": is_strict_clean_title(clean_title, nm),
-        "extractor_source": "raw_neural_span_bio",
-    }
+    # BIO tags index bytes; char spans are derived through the offset table
+    # (never by reusing byte offsets as char offsets). `res_*` stays empty
+    # here to keep this decoder purely neural; the hybrid fills it.
+    return _with_span_aliases(
+        {
+            "title": clean_title,
+            "title_byte_span": (tb, te),
+            "year": year_val,
+            "year_byte_span": year_bspan,
+            "episode_spec": ep_val,
+            "episode_byte_span": ep_bspan,
+            "is_anchored": is_strict_clean_title(clean_title, nm),
+            "extractor_source": "raw_neural_span_bio",
+        },
+        nm,
+    )
 
 
 def decode_bio_tags_to_spans(raw_name: str, bio_tags: Sequence[int] | Any) -> dict[str, Any]:
-    """Hybrid Neural + Structural Span Decoder."""
+    """Hybrid Neural + Structural Span Decoder.
+
+    The returned dict always carries the full span key contract
+    (`title_span`, `title_span_bytes`, `year_span`, `res_span`, ...), so
+    consumers such as `ws2_catalog_and_bio.py` can never hit the R11
+    `KeyError: 'title_span_bytes'` crash regardless of which branch wins.
+    """
     neural_res = decode_bio_tags_raw_neural(raw_name, bio_tags)
     struct_res = extract_byte_spans_v3(raw_name)
     if neural_res["is_anchored"]:
@@ -692,5 +846,8 @@ def decode_bio_tags_to_spans(raw_name: str, bio_tags: Sequence[int] | Any) -> di
         inter = max(0, min(ne, se) - max(nb, sb))
         union = max(1, max(ne, se) - min(nb, sb))
         if inter / union >= 0.65:
-            return neural_res
-    return struct_res
+            for key in ("res", "res_byte_span", "res_span_bytes", "res_span"):
+                if neural_res.get(key) is None:
+                    neural_res[key] = struct_res.get(key)
+            return _with_span_aliases(neural_res, raw_name)
+    return _with_span_aliases(struct_res, raw_name)

calibration.json

@@ -1,5 +1,5 @@
 {
-  "calibrated_onnx_fp32_sha256": "6f94aef676e5bec4968378437769cfdc768fefcc6a21854b8319b33456ebd2ec",
+  "calibrated_onnx_fp32_sha256": "ebed96dfef6f78842768ecdad646f6e5d838681feed9a4919d4b95aa0f912ea4",
   "calibration_version": "v3.0-gold-r13_3-val-only",
   "feature_stats_dim": 41,
   "fitted_snapshot_id": "snap_r13_20261024T140340Z_064c8e6ccb1f",

config.json

@@ -1,27 +1,28 @@
 {
-  "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",
+  "model_name": "armiger-ultra",
+  "version": "2.1.0",
+  "bundle_type": "unified_armiger_plus_ultra_plus_swarm",
+  "architecture": "armiger-v2-byte-rope-transformer-8head + residual-swarm-health-adapter",
   "artifacts": {
-    "armiger.onnx": {
-      "size_bytes": 17599636,
-      "sha256": "c0e96936038988c7465b7fe041c4dc3c92df5a8cb4f56c2666271cd4d3e79420"
+    "armiger_cpu_int8_onnx": {
+      "file": "armiger.int8.onnx",
+      "size_bytes": 17604743,
+      "sha256": "02d185e673e8552a6b09d921b1bf8bc6e64cdb4ba984ffacdbe804b487132271"
     },
-    "calibration.json": {
-      "size_bytes": 76612,
-      "sha256": "300387779dc16292dd9e6be038ce9dd60e5bdb0ee929b383dcd4e51715f8b5f8"
+    "armiger_ultra_fp32_onnx": {
+      "file": "armiger_ultra.fp32.onnx",
+      "size_bytes": 33258907,
+      "sha256": "ebed96dfef6f78842768ecdad646f6e5d838681feed9a4919d4b95aa0f912ea4"
     },
-    "vocab.json": {
-      "size_bytes": 39996,
-      "sha256": "c10afea430188e0207752e93bf0b340fbb585858684037c5134a477cbc0dd7bb"
+    "armiger_ultra_pytorch": {
+      "file": "armiger_ultra.pt",
+      "size_bytes": 33534627,
+      "sha256": "3d04f0870c63ab7a12b1a963419692007f8bf811f702ccaa55a5e8f99f5f941b"
     },
-    "armiger_inference.py": {
-      "size_bytes": 38228,
-      "sha256": "c345587c57cecc518626852d0d8fcacf5ebb1576c10c0df6608f851a9ec72c31"
+    "swarm_health_adapter": {
+      "file": "swarm_adapter.pt",
+      "size_bytes": 144144,
+      "sha256": "4e4c7a2dd59fb91a234e6627e7ade35062f99268d3f05370432bb9f2a2f9b1c9"
     }
   },
   "heads": {
@@ -74,91 +75,106 @@
     "junk": 0.101,
     "owner_scope": 0.477
   },
-  "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
-    },
-    "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
-    },
-    "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
+  "benchmarks": {
+    "gold_standard_11class_category_acc": 98.48,
+    "movie_vs_tv_acc": 99.46,
+    "catalog_matching_rate_acc": 98.69,
+    "audio_language_acc": 98.72,
+    "anime_and_dub_acc": 97.92,
+    "adult_safety_gate_acc": 98.63,
+    "junk_malware_filter_acc": 99.95,
+    "swarm_liveliness_auroc": 96.83,
+    "fake_seeder_honeypot_recall": 100.0,
+    "overall_6dim_composite_mean": 98.74,
+    "gpu_batched_latency_ms": 0.5,
+    "gpu_single_item_latency_ms": 1.12,
+    "cpu_int8_batched_latency_ms": 0.42
+  },
+  "bundled_plugins": {
+    "armiger-swarm-survival": {
+      "files": [
+        "swarm_adapter.pt",
+        "swarm_survival.py"
+      ],
+      "sha256": {
+        "swarm_adapter.pt": "4e4c7a2dd59fb91a234e6627e7ade35062f99268d3f05370432bb9f2a2f9b1c9",
+        "swarm_survival.py": "9dfbe7c4961f5a53bb4e40fc4450ebf958398157148d9f54da100d75dd24caf0"
+      }
     },
-    "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-swarm-priors": {
+      "files": [
+        "swarm_priors.py"
+      ],
+      "sha256": {
+        "swarm_priors.py": "49b2b6857802606158e4a1de8cdc335e485be83aaec5405b9f2fd103ca90b394"
+      }
     },
-    "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-zero-cue-catalog": {
+      "files": [
+        "zero_cue_plugin.py",
+        "validated_zero_cue_catalog.json"
+      ],
+      "sha256": {
+        "zero_cue_plugin.py": "57bba15c57e3d83420367605c131c57e17863f8e7ab2c10b0196177c6c7ae28d",
+        "validated_zero_cue_catalog.json": "8a8b7a4ba97cb22c3aa1f75ab33762052deb09580df464b1eabfe622a2837d26"
+      }
     },
-    "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
+    "armiger-audio-guard": {
+      "files": [
+        "audio_language_guard.py"
+      ],
+      "sha256": {
+        "audio_language_guard.py": "8c4de62592ec3174cda6467dccd575c4125fcb32a04603d4c16850267a0ac9f4"
+      }
     },
-    "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
+    "armiger-calibration-dht": {
+      "files": [
+        "calibration.json",
+        "calibration_and_dht.py",
+        "armiger_dht_rsi.py",
+        "test_armiger_dht_rsi.py"
+      ],
+      "sha256": {
+        "calibration.json": "ea7a4df70747160b41ae0cbca0292562f097bbbea7b5d549c5348f743e30b33c",
+        "calibration_and_dht.py": "11be587b60202185abbcf507b935464fed5be5d7c0b28adc38fe5213ca088db5",
+        "armiger_dht_rsi.py": "3b709c506e0826fded14d3180516982f91b003f4ad3381a9b13e3909900e11e4",
+        "test_armiger_dht_rsi.py": "f284d290cc2a847f152e51ff40112556caf6c256ee2629aa9f31afbefa73d2df"
+      }
     },
-    "overall_6dim_composite_mean": 96.5
+    "armiger-dht-db-sync": {
+      "files": [
+        "csam_guard.py",
+        "armiger_dht_db_sync.py",
+        "test_dht_db_sync.py"
+      ],
+      "sha256": {
+        "csam_guard.py": "9f91038e25505e984ba2a89f411fc2f89145393a8f811e2fe7a6025a7c73a31c",
+        "armiger_dht_db_sync.py": "f80ea1c58170cf205c2222f28302afb7305cb9ddf4707fc6bff6ac6f6cb67d92",
+        "test_dht_db_sync.py": "ed6cebbcbaebc0d43516f68952937696a6b6c88ec54da8536112f9127b4f4290"
+      }
+    }
   },
-  "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
+  "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": "636e0414dd4d039cea3c46bea9a69d2cf31b487a86a357a4e37e877ea9c1e8a0",
+      "test_armiger_ultra_pipeline.py": "b309d0edf87a189f41e95c18511fd26b0d748f981d93f1a0782cd8163015e18d"
+    }
   },
-  "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
-  }
+  "parameter_count": 8050139
 }