Align model card, NOTICE, config digests, and documentation with v2.1.0 audit

LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 NorviTech / Spencer Norton
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,47 @@
+Armiger & Armiger Ultra
+Copyright 2026 NorviTech / Spencer Norton
+
+This product includes software, neural network weights, calibration parameters,
+and domain-separated hash lookup tables developed by NorviTech and released
+under the Apache License, Version 2.0.
+
+================================================================================
+Creative Commons & Public-Domain Example Media Attributions
+================================================================================
+Media titles and filenames used in documentation examples and unit test fixtures
+in this repository reference open-source, Creative Commons, or public-domain
+works:
+
+- "Big Buck Bunny" (2008), "Sintel" (2010), "Tears of Steel" (2012),
+  "Cosmos Laundromat" (2015), "Caminandes" (2013-2016), "Spring" (2019),
+  "Coffee Run" (2020), "Charge" (2022), "Wing It!" (2023), and
+  "Elephants Dream" (2006) are Open Movies produced by the Blender Foundation
+  (https://studio.blender.org/films/), licensed under Creative Commons
+  Attribution (CC-BY 3.0 / CC-BY 4.0).
+- "Le Voyage dans la Lune" (1902) and "Les Quatre Cents Farces du Diable" (1906)
+  by Georges Melies are in the public domain.
+- "Pepper&Carrot" is an open-source webcomic by David Revoy
+  (https://www.peppercarrot.com/), licensed under Creative Commons Attribution
+  4.0 International (CC-BY 4.0).
+- "Open Goldberg Variations" (BWV 988) by J.S. Bach, performed by Kimiko Ishizaka,
+  is released into the public domain under Creative Commons Zero (CC0 1.0).
+- "Pride and Prejudice" by Jane Austen (1813) is in the public domain worldwide;
+  LibriVox recordings (https://librivox.org/) are released into the public domain
+  in the United States (verify local copyright duration outside the U.S.).
+
+================================================================================
+Domain-Separated Hash Representation & Non-Affiliation Notice
+================================================================================
+- The Zero-Cue Title Catalog (`validated_zero_cue_catalog.json`) and release-tag
+  feature extractors store lookup keys as domain-separated 64-bit BLAKE2b digests
+  (`person=b"armiger-zc-v2"` / 8-byte hex digests) mapped to integer catalog IDs
+  and coarse category/language codes. No plaintext media titles or release-group
+  names are redistributed in the catalog file.
+- BitTorrent, BEP-5, BEP-9, BEP-10, BEP-15, BEP-44, BEP-46, and BEP-51 are open
+  protocol specifications. All third-party product names, open-source project
+  names, and model names (including OpenAI, GPT, Anthropic, Claude, Google,
+  Gemini, GuessIt, RTN/Parsett, PTN, Anitomy, MIMMO, Bitmagnet, ONNX Runtime,
+  and PyTorch) referenced in comparative benchmarks or compatibility guides
+  remain the property of their respective owners. Use of these names is strictly
+  nominative for comparative technical evaluation or interoperability description
+  and implies no endorsement, sponsorship, or affiliation.

README.md

@@ -29,7 +29,7 @@ pipeline_tag: other
   <a href="https://huggingface.co/NorviTech/armiger-ultra"><img alt="Compatible with Armiger Ultra" src="https://img.shields.io/badge/Bundled_with-Armiger_Ultra-FD8024.svg"></a>
   <a href="https://huggingface.co/NorviTech/armiger"><img alt="Compatible with Armiger" src="https://img.shields.io/badge/Compatible_with-Armiger_CPU-0284C7.svg"></a>
   <img alt="Licence Apache-2.0" src="https://img.shields.io/badge/licence-Apache--2.0-blue.svg">
-  <img alt="Tests Passing" src="https://img.shields.io/badge/tests-37%2F37%20passing-brightgreen.svg">
+  <img alt="Tests Passing" src="https://img.shields.io/badge/tests-27%2F27%20passing-brightgreen.svg">
 </p>
 
 ---
@@ -97,7 +97,7 @@ sync_engine = ArmigerDHTDatabaseSync(
 # 2. Ingest candidate record with CSAM & safety checks
 ok, msg, record = sync_engine.ingest_candidate_record(
     infohash="0123456789abcdef0123456789abcdef01234567",
-    title="Spring.Complete.1080p.BluRay.x265",
+    title="Spring.2019.1080p.WEBM.AV1-OPEN",
     category="anime",
     language="ja",
     quality_tier="hd_1080p",
@@ -126,7 +126,7 @@ print("Tombstone purge executed. Purged records:", purged)
 
 ## Test Suite Execution
 
-Run the comprehensive 37-point unit + live 12-node UDP wire test suite (`test_dht_db_sync.py` + `test_bep44_udp_wire_e2e.py`):
+Run the comprehensive 27-point test suite:
 
 ```bash
 python3 test_dht_db_sync.py -v
@@ -167,53 +167,13 @@ Ran 27 tests in 0.011s - OK
 
 ---
 
-## Part of the Armiger Modular Plugin Suite
+## Part of the Armiger Modular Suite
 
-| Plugin Repository | Bundled in `Armiger Ultra`? | Footprint | Core Capability & Measured Impact (Unmutated Ground-Truth Keys) |
-| :--- | :---: | :---: | :--- |
-| **[`NorviTech/armiger-swarm-survival`](https://huggingface.co/NorviTech/armiger-swarm-survival)** | **Yes** (`swarm_adapter.pt`, `swarm_survival.py`) | `167 KB` (`132 KB` `.pt`) | **SwarmSurvivalNet v2 & Honeypot Residual Adapter:** Executes full 48-tensor neural forward pass (`SwarmResidualAdapter`); **`96.83%`** Multi-Source Warehouse AUROC (`N=10,278`, vs. `53.02%` raw seeders), **`92.42%`** / **`93.03%`** Public-Tracker AUROC (`N=757` / `N=493`, vs. `85.17%` raw seeders), **`100.0%`** fake-seeder malware trap recall, **`0.00%`** content-category flip guarantee. |
-| **[`NorviTech/armiger-swarm-priors`](https://huggingface.co/NorviTech/armiger-swarm-priors)** | **Yes** (`swarm_priors.py`) | `29.3 KB` | **Empirical Bayes Swarm & Release-Group Priors:** 4-pathway tracker scrape prior engine (`86.64%` formula AUROC), mandatory modality dropout (`p=0.60`), anomaly feature extraction, and public-tracker passkey safety filter. |
-| **[`NorviTech/armiger-zero-cue-catalog`](https://huggingface.co/NorviTech/armiger-zero-cue-catalog)** | **Yes** (`zero_cue_plugin.py`, `validated_zero_cue_catalog.json`) | `26.0 MB` (`BLAKE2b-64`) | **Zero-Cue Catalog & Structural Disambiguator:** Offline `929,400`-entry `BLAKE2b-64` cryptographically hashed catalog (`472,017` `(title, year)`, `257,016` anime stems, `200,367` long titles) + deterministic structural rules; lifts 5-split (`N=10,262`) weighted category accuracy from **`94.00%`** (Standalone Neural) to **`95.42%`** (Fair Blind Hybrid), `beyond_confirmation` (`N=1,025`) from **`92.88%`** to **`95.12%`**, and `tc_truespec_2000` (`N=2,000`) from **`87.40%`** to **`91.50%`** (`+4.10 pp`). |
-| **[`NorviTech/armiger-audio-guard`](https://huggingface.co/NorviTech/armiger-audio-guard)** | **Yes** (`audio_language_guard.py`) | `3.3 KB` | **Cross-Head Audio Language & Anime Dub Guard:** Couples `title_language` (`P(Foreign Title)`) with `lang` head to disambiguate `.en.` prepositions, `<Foreign>.ENG.Sub`, regional dubs, and `MULTi (FR EN)` tags; lifts binary English-vs-Foreign audio accuracy on `oct15_confirmation` (`N=545`) from **`96.88%`** (Standalone Neural) to **`97.80%`** (`92.75%` 3-class `N=772`). |
-| **[`NorviTech/armiger-calibration-dht`](https://huggingface.co/NorviTech/armiger-calibration-dht)** | **Yes** (`calibration.json`, `calibration_and_dht.py`, `armiger_dht_rsi.py`) | `181 KB` | **Conformal Calibration, BEP-44 DHT Updater & Distributed RSI Engine:** Per-head temperature scaling ($T_h$), Mondrian safety gates (**`100.00%`** junk accuracy on `oct15_confirmation` `N=2,170` & `fresh_confirmation` `N=1,291`, **`99.90%`** on `beyond_confirmation` `N=977`), Hybrid `Ed25519`+`WOTS+-SHAKE256` signed `BEP-44`/`BEP-46` DHT hot-reload, Hybrid `X25519`+`ML-KEM-768`+`ChaCha20-Poly1305` AEAD, distinct-ASN quorum, strictly **opt-in-by-default (`opt_in_sharing=False`)** anonymous sharing via `AnonymityGuard` (`500/500` leak block rate, ephemeral `Ed25519` keys, coarse UTC hour bucketing, DP-clipped deltas), and 500-canary regression gate. |
-| **[`NorviTech/armiger-dht-db-sync`](https://huggingface.co/NorviTech/armiger-dht-db-sync)** | **Yes** (`csam_guard.py`, `armiger_dht_db_sync.py`) | `155 KB` | **Modular, CSAM-Protected, Encrypted BEP-44/BEP-46 DHT Database Sync:** Multi-stage CSAM & abuse pre-ingest blocker, Hybrid PQ-signed blinded `SHA-256` tombstone purge engine, 10-category $\times$ 14-language $\times$ 7-quality sharded subscriptions with strict default-off `xxx` isolation, `X25519`+`ML-KEM-768`+`ChaCha20-Poly1305` AEAD, binary Merkle proofs, strictly **opt-in-by-default (`opt_in_sharing=False`)** `BLAKE2b-64` one-way catalog hashing via `AnonymityGuard`, and $K$-of-$N$ distinct-ASN Sybil quorum. |
-
----
-
-## Canonical Statistical Chart Audit & Cryptographic Provenance (`v2.1.0`)
-
-All benchmark charts and headline metrics across the Armiger `v2.1.0` suite are generated deterministically from [`benchmarks/canonical_eval_vectors.json`](https://huggingface.co/NorviTech/armiger-ultra/blob/main/benchmarks/canonical_eval_vectors.json) (`0` strings, titles, or infohashes) and locked by [`benchmarks/CHARTS_MANIFEST.json`](https://huggingface.co/NorviTech/armiger-ultra/blob/main/benchmarks/CHARTS_MANIFEST.json) under four machine-enforced invariants (`pytest benchmarks/test_chart_integrity.py`):
-
-1. **Identical Denominator Lock (`assert_identical_denominator`):** Every model compared on a benchmark bar shares the exact same item count $N$ and item mask (`oct15_confirmation` $N=2,835$; `beyond_confirmation` $N=1,025$; Movie-vs-TV $N=1,296$; Audio $N=545$; Anime $N=507$; Junk $N=2,170$).
-2. **Non-Circular Teacher Evaluation Lock (`assert_non_circular_teacher_eval`):** Frontier teacher models (`gpt-6-luna`, `gemini-3.8-flash-low`) are evaluated strictly via **Leave-One-Teacher-Out (LOTO)** reference keys (`self_vote_weight = 0.0`), removing $+1.47\text{ pp}$ and $+1.81\text{ pp}$ of circular self-vote inflation.
-3. **Paired Bootstrap 95% CIs & Exact McNemar $p$-Values:** Computed using `10,000` paired resamples (`seed = 20261018`, integer-scaled `float64` dot products) and exact binomial `math.comb` McNemar tests (`p = 1.42e-11` vs. `gemini-3.8-flash-low` LOTO; `p = 3.88e-24` vs. `claude-haiku-4-5`).
-4. **Deterministic PNG Chunk Stripping:** Output PNGs contain only `IHDR`, `IDAT`, and `IEND` chunks with pinned SHA-256 digests (`2367dbf6...`, `ff33da1a...`, `a4ebfcb1...`, `b137523c...`).
-
----
-
-## Privacy & Anonymous Opt-In-By-Default DHT Sharing (`opt_in_sharing=False`)
-
-Distributed DHT intelligence sharing (`NorviTech/armiger-calibration-dht` and `NorviTech/armiger-dht-db-sync`) is **strictly opt-in by default** and **100% anonymous by construction** when enabled (see [`docs/ANONYMOUS_OPT_IN_DHT.md`](https://huggingface.co/NorviTech/armiger-ultra/blob/main/docs/ANONYMOUS_OPT_IN_DHT.md) and [`benchmarks/anonymous_opt_in_proof_report.json`](https://huggingface.co/NorviTech/armiger-ultra/blob/main/benchmarks/anonymous_opt_in_proof_report.json)):
-
-| Guarantee | Default State | Wire-Level & Mathematical Enforcement |
-| :--- | :--- | :--- |
-| **Opt-In by Default** | `opt_in_sharing=False` (`ARMIGER_DHT_SHARE_OPT_IN="0"`) | `0` outbound DHT packets are emitted unless the operator explicitly opts in (`opt_in_sharing=True` and `ARMIGER_DHT_SHARE_OPT_IN="1"`). |
-| **`AnonymityGuard` Wire Firewall** | Always active (`500/500` canary block rate) | Inspects every outbound payload before signing; blocks `100.0%` (`500/500`) of synthetic leaks containing raw 40-hex infohashes, release titles, file paths, tracker URLs, passkeys, IPv4/IPv6 addresses, or hostnames. |
-| **Ephemeral `Ed25519` Keys** | Single-use keypair per announcement | Rotates a fresh 32-byte `Ed25519` keypair and `ephemeral_node_id` on every publish so contributions are unlinkable across time. |
-| **Coarse UTC Hour Timestamps** | `epoch_ts = (utc_now // 3600) * 3600` | Quantizes all outbound timestamps to 1-hour UTC boundaries (`3600s`), eliminating clock-skew and grab-timing correlation. |
-| **DP-Clipped Weight Deltas** | `clip_norm = 1.0`, `noise_multiplier = 0.05` | Clips calibration/adapter update vectors in $L_2$ norm (`<= 1.0`) and adds calibrated Gaussian noise ($\sigma = 0.05$) before hybrid `X25519` + `ML-KEM-768` + `ChaCha20-Poly1305` encryption. |
-| **`BLAKE2b-64` One-Way Catalog Hashes** | 16-hex-char (`64-bit`) digest | Shared catalog entries store only domain-separated `BLAKE2b-64` title hashes mapped to integer catalog IDs—never raw torrent names or infohashes. |
-
----
+This plugin is bundled inside **[`NorviTech/armiger-ultra`](https://huggingface.co/NorviTech/armiger-ultra)** alongside all 6 official plugins (`armiger-swarm-survival`, `armiger-swarm-priors`, `armiger-zero-cue-catalog`, `armiger-audio-guard`, `armiger-calibration-dht`, and `armiger-dht-db-sync`) and is compatible with **[`NorviTech/armiger`](https://huggingface.co/NorviTech/armiger)** (`8.3 MB` CPU INT8).
 
 ## Intended Use & Legal Compliance
 
-`Armiger`, `Armiger Ultra`, and all bundled plugins are open-source machine learning and cryptographic metadata-classification utilities designed strictly for **lawful use cases**, including:
-- Organizing and indexing licensed, public-domain, Creative Commons, and open-source digital media, software distributions (e.g., Linux ISOs, open-source games), and educational archives (e.g., OpenCourseWare, LibriVox, Project Gutenberg).
-- Automated cybersecurity screening, fake-seeder honeypot detection, and disguised executable/malware filtering (`.mkv.exe`, `.scr`, `.vbs`) in peer-to-peer and decentralized storage research.
-- Child safety (CSAM/CSAE) pre-ingest blocking, cryptographic tombstone revocation, and adult/NSFW namespace isolation for self-hosted and decentralized indexers.
-
-**NorviTech does not condone, encourage, or support copyright infringement or the unauthorized distribution of copyrighted works.** Users are solely responsible for ensuring that their use of these models and plugins complies with all applicable local, national, and international copyright and data-protection laws.
+Open-source machine learning and cryptographic metadata-classification utility designed strictly for **lawful use cases** (indexing licensed, public-domain, Creative Commons, and open-source media/software; malware & fake-seeder honeypot filtering; and CSAM/abuse pre-ingest blocking). **NorviTech does not condone, encourage, or support copyright infringement.** See [`LEGAL.md`](https://huggingface.co/NorviTech/armiger-ultra/blob/main/LEGAL.md) and [`NOTICE`](NOTICE).
 
 ---
 

armiger_dht_db_sync.py

@@ -219,6 +219,10 @@ class QuorumAttestation:
             "timestamp": int(self.timestamp),
         }
 
+    def signing_payload(self, manifest_digest: bytes) -> bytes:
+        meta = json.dumps(self.canonical_dict(), sort_keys=True, separators=(",", ":")).encode("utf-8")
+        return hashlib.sha256(b"armiger-attestation-v2:" + manifest_digest + b":" + meta).digest()
+
 
 @dataclasses.dataclass(frozen=True)
 class DHTShardManifest:
@@ -1090,9 +1094,15 @@ class QuorumVerifier:
             if isinstance(att.asn, bool) or not isinstance(att.asn, int) or att.asn <= 0:
                 continue
 
+            bound_digest = att.signing_payload(manifest_digest)
+            sig_msg_used = bound_digest
             try:
                 node_vk = Ed25519PublicKey.from_public_bytes(bytes.fromhex(norm_pk))
-                node_vk.verify(bytes.fromhex(norm_sig), manifest_digest)
+                try:
+                    node_vk.verify(bytes.fromhex(norm_sig), bound_digest)
+                except InvalidSignature:
+                    node_vk.verify(bytes.fromhex(norm_sig), manifest_digest)
+                    sig_msg_used = manifest_digest
             except (InvalidSignature, ValueError):
                 continue
 
@@ -1100,7 +1110,10 @@ class QuorumVerifier:
                 try:
                     node_pq_pk = bytes.fromhex(att.pq_pubkey_hex.strip().lower())
                     node_pq_sig = bytes.fromhex(att.pq_signature_hex.strip())
-                    if not WOTSPlusSHAKE256.verify(node_pq_pk, manifest_digest, node_pq_sig):
+                    if not (
+                        WOTSPlusSHAKE256.verify(node_pq_pk, sig_msg_used, node_pq_sig)
+                        or WOTSPlusSHAKE256.verify(node_pq_pk, manifest_digest, node_pq_sig)
+                    ):
                         continue
                 except ValueError:
                     continue
@@ -1664,11 +1677,20 @@ def create_mock_quorum_attestations(
     for asn in distinct_asns:
         priv, pub = generate_ed25519_keypair()
         sk = Ed25519PrivateKey.from_private_bytes(priv)
-        sig = sk.sign(manifest_digest)
-        pq_priv, pq_pub = WOTSPlusSHAKE256.derive_keypair_from_ed25519_priv(priv)
-        pq_sig = WOTSPlusSHAKE256.sign(pq_priv, manifest_digest)
         node_id = hashlib.sha1(pub + f"asn{asn}".encode()).hexdigest()
         ip_digest = hashlib.sha256(f"192.0.2.{asn % 250}".encode()).hexdigest()
+        temp_att = QuorumAttestation(
+            node_id=node_id,
+            asn=int(asn),
+            ip_digest=ip_digest,
+            pubkey_hex=pub.hex(),
+            signature_hex="",
+            timestamp=ts,
+        )
+        bound_msg = temp_att.signing_payload(manifest_digest)
+        sig = sk.sign(bound_msg)
+        pq_priv, pq_pub = WOTSPlusSHAKE256.derive_keypair_from_ed25519_priv(priv)
+        pq_sig = WOTSPlusSHAKE256.sign(pq_priv, bound_msg)
 
         attestations.append(QuorumAttestation(
             node_id=node_id,

benchmarks/CHARTS_MANIFEST.json

@@ -0,0 +1,1575 @@
+{
+  "schema_version": "1.0.0",
+  "bootstrap_seed": 20261018,
+  "bootstrap_resamples": 10000,
+  "invariants_verified": {
+    "identical_denominator_lock": true,
+    "anti_circularity_lock": true,
+    "paired_uncertainty_and_significance": true,
+    "png_metadata_stripped_ihdr_idat_iend_only": true
+  },
+  "anti_circularity_audit": [
+    {
+      "model_name": "OpenAI GPT (Fast Tier)",
+      "is_teacher": true,
+      "eval_mode": "leave_one_teacher_out",
+      "self_vote_weight": 0.0,
+      "non_circular_pct": 95.12,
+      "circular_self_vote_pct": 96.59,
+      "circularity_inflation_pp": 1.46
+    },
+    {
+      "model_name": "Google Gemini Flash",
+      "is_teacher": true,
+      "eval_mode": "leave_one_teacher_out",
+      "self_vote_weight": 0.0,
+      "non_circular_pct": 93.8,
+      "circular_self_vote_pct": 95.61,
+      "circularity_inflation_pp": 1.8
+    },
+    {
+      "model_name": "Anthropic Claude Haiku 4.5",
+      "is_teacher": true,
+      "eval_mode": "independent_ground_truth",
+      "self_vote_weight": 0.0
+    }
+  ],
+  "provenance_sha256": {
+    "canonical_eval_vectors.json": "058473f4ba21bc07db2c2b6981d5e62f3c584311fc134d92cb523de7f261243a",
+    "generate_canonical_charts.py": "e6d73c7197057fbb7cea3dee7f11599e6ce50039f692eada2d0ebae61ec774c4",
+    "assets/armiger_vs_llms_overall_and_6dims.png": "0a0bc3a260b3c3b1188a92fb9cc015c6bdb786e9033924d9daa7a36be332fc62",
+    "assets/armiger_vs_llms_cost_comparison.png": "3cf46fd59817d3bffafce1f4f5a15379ffef7bf779b8d4b40b866a8d9671eff4",
+    "assets/armiger_vs_torrent_classifiers_6dims.png": "e6be359c5cc980b4fe30810d4f2f5b8b202bd3fca6f2a4a33ae0727c5de2f010",
+    "assets/armiger_categorical_breakdown.png": "1a77a64340f7e05af318105d83270b29396450d01f22f71cffdf808b45e10d98",
+    "validated_zero_cue_catalog.json": "a43193a7d9982f1b83e9e6968c47dbbe8d058b113af5020d6d5ea45ed2af7fcd",
+    "armiger_ultra.fp32.onnx": "24c65e1af1be68c923bfdf774afb862c54b66a30f40c4b65cf5961929f149d48",
+    "armiger.int8.onnx": "c750e034aace4ff28c0eb1e1112b28f744a5770abd78618127258f283e54e4da"
+  },
+  "charts": {
+    "armiger_vs_llms_overall_and_6dims.png": {
+      "sha256": "0a0bc3a260b3c3b1188a92fb9cc015c6bdb786e9033924d9daa7a36be332fc62",
+      "composite_6dim_mean": {
+        "Armiger Ultra (Fair Hybrid)": {
+          "point_pct": 96.86,
+          "ci95_lo": 96.35,
+          "ci95_hi": 97.38,
+          "point_with_corpus_swarm_pct": 97.6
+        },
+        "Armiger (8.3 MB INT8 + Plugins)": {
+          "point_pct": 96.85,
+          "ci95_lo": 96.33,
+          "ci95_hi": 97.36
+        },
+        "Google Gemini Flash": {
+          "point_pct": 94.56,
+          "ci95_lo": 93.88,
+          "ci95_hi": 95.23
+        },
+        "Anthropic Claude Haiku 4.5": {
+          "point_pct": 92.88,
+          "ci95_lo": 92.04,
+          "ci95_hi": 93.72
+        },
+        "OpenAI GPT (Fast Tier)": {
+          "point_pct": 86.24,
+          "ci95_lo": 85.56,
+          "ci95_hi": 86.91
+        },
+        "Local 8B Instruct LLM (FP16)": {
+          "point_pct": 84.79,
+          "ci95_lo": 83.65,
+          "ci95_hi": 85.94
+        }
+      },
+      "panel_2a_category_11class": {
+        "panel_name": "chart1_2a_beyond_cat11",
+        "n": 1025,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 1025,
+            "point_pct": 95.12,
+            "ci95_lo": 93.76,
+            "ci95_hi": 96.39,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 1025,
+            "point_pct": 95.12,
+            "ci95_lo": 93.76,
+            "ci95_hi": 96.39,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Google Gemini Flash": {
+            "n": 1025,
+            "point_pct": 93.8,
+            "ci95_lo": 92.39,
+            "ci95_hi": 95.12,
+            "delta_vs_ref_pct": 1.32,
+            "delta_ci95_lo": -0.29,
+            "delta_ci95_hi": 2.93,
+            "p_value_vs_ref": 0.1073516
+          },
+          "Anthropic Claude Haiku 4.5": {
+            "n": 1025,
+            "point_pct": 93.76,
+            "ci95_lo": 92.2,
+            "ci95_hi": 95.22,
+            "delta_vs_ref_pct": 1.37,
+            "delta_ci95_lo": 0.68,
+            "delta_ci95_hi": 2.15,
+            "p_value_vs_ref": 0.0001220703
+          },
+          "OpenAI GPT (Fast Tier)": {
+            "n": 1025,
+            "point_pct": 95.12,
+            "ci95_lo": 93.85,
+            "ci95_hi": 96.29,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": -1.46,
+            "delta_ci95_hi": 1.41,
+            "p_value_vs_ref": 0.5715867
+          },
+          "Local 8B Instruct LLM (FP16)": {
+            "n": 1025,
+            "point_pct": 80.78,
+            "ci95_lo": 78.34,
+            "ci95_hi": 83.22,
+            "delta_vs_ref_pct": 14.34,
+            "delta_ci95_lo": 12.2,
+            "delta_ci95_hi": 16.49,
+            "p_value_vs_ref": 1.121039e-44
+          }
+        }
+      },
+      "panel_2b_catalog_matching": {
+        "panel_name": "chart1_2b_beyond_matching",
+        "n": 1025,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 1025,
+            "point_pct": 96.39,
+            "ci95_lo": 95.22,
+            "ci95_hi": 97.46,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 1025,
+            "point_pct": 96.29,
+            "ci95_lo": 95.02,
+            "ci95_hi": 97.37,
+            "delta_vs_ref_pct": 0.1,
+            "delta_ci95_lo": -0.69,
+            "delta_ci95_hi": 0.98,
+            "p_value_vs_ref": 1.0
+          },
+          "Google Gemini Flash": {
+            "n": 1025,
+            "point_pct": 90.88,
+            "ci95_lo": 89.17,
+            "ci95_hi": 92.49,
+            "delta_vs_ref_pct": 5.51,
+            "delta_ci95_lo": 3.71,
+            "delta_ci95_hi": 7.32,
+            "p_value_vs_ref": 3.767158e-09
+          },
+          "Anthropic Claude Haiku 4.5": {
+            "n": 1025,
+            "point_pct": 86.15,
+            "ci95_lo": 84.0,
+            "ci95_hi": 88.2,
+            "delta_vs_ref_pct": 10.24,
+            "delta_ci95_lo": 8.39,
+            "delta_ci95_hi": 12.1,
+            "p_value_vs_ref": 4.930381e-32
+          },
+          "OpenAI GPT (Fast Tier)": {
+            "n": 1025,
+            "point_pct": 89.07,
+            "ci95_lo": 87.17,
+            "ci95_hi": 90.88,
+            "delta_vs_ref_pct": 7.32,
+            "delta_ci95_lo": 5.37,
+            "delta_ci95_hi": 9.32,
+            "p_value_vs_ref": 2.797646e-13
+          },
+          "Local 8B Instruct LLM (FP16)": {
+            "n": 1025,
+            "point_pct": 77.85,
+            "ci95_lo": 75.32,
+            "ci95_hi": 80.29,
+            "delta_vs_ref_pct": 18.54,
+            "delta_ci95_lo": 16.29,
+            "delta_ci95_hi": 20.98,
+            "p_value_vs_ref": 1.274474e-57
+          }
+        }
+      },
+      "panel_2c_audio_strict_229": {
+        "panel_name": "chart1_2c_beyond_audio_strict",
+        "n": 229,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 229,
+            "point_pct": 99.13,
+            "ci95_lo": 97.82,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 229,
+            "point_pct": 99.13,
+            "ci95_lo": 97.82,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Google Gemini Flash": {
+            "n": 229,
+            "point_pct": 98.69,
+            "ci95_lo": 96.94,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.44,
+            "delta_ci95_lo": -1.31,
+            "delta_ci95_hi": 2.18,
+            "p_value_vs_ref": 1.0
+          },
+          "Anthropic Claude Haiku 4.5": {
+            "n": 229,
+            "point_pct": 95.63,
+            "ci95_lo": 92.58,
+            "ci95_hi": 98.25,
+            "delta_vs_ref_pct": 3.49,
+            "delta_ci95_lo": 1.31,
+            "delta_ci95_hi": 6.11,
+            "p_value_vs_ref": 0.0078125
+          },
+          "OpenAI GPT (Fast Tier)": {
+            "n": 229,
+            "point_pct": 97.82,
+            "ci95_lo": 95.63,
+            "ci95_hi": 99.56,
+            "delta_vs_ref_pct": 1.31,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 3.06,
+            "p_value_vs_ref": 0.25
+          },
+          "Local 8B Instruct LLM (FP16)": {
+            "n": 229,
+            "point_pct": 93.45,
+            "ci95_lo": 89.96,
+            "ci95_hi": 96.51,
+            "delta_vs_ref_pct": 5.68,
+            "delta_ci95_lo": 3.06,
+            "delta_ci95_hi": 8.73,
+            "p_value_vs_ref": 0.0002441406
+          }
+        }
+      },
+      "panel_2d_anime_valid_636": {
+        "panel_name": "chart1_2d_beyond_anime_valid636",
+        "n": 636,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 636,
+            "point_pct": 98.9,
+            "ci95_lo": 97.96,
+            "ci95_hi": 99.69,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 636,
+            "point_pct": 98.9,
+            "ci95_lo": 97.96,
+            "ci95_hi": 99.69,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Google Gemini Flash": {
+            "n": 636,
+            "point_pct": 95.6,
+            "ci95_lo": 93.87,
+            "ci95_hi": 97.17,
+            "delta_vs_ref_pct": 3.3,
+            "delta_ci95_lo": 1.73,
+            "delta_ci95_hi": 5.03,
+            "p_value_vs_ref": 4.923344e-05
+          },
+          "Anthropic Claude Haiku 4.5": {
+            "n": 636,
+            "point_pct": 98.9,
+            "ci95_lo": 97.96,
+            "ci95_hi": 99.69,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "OpenAI GPT (Fast Tier)": {
+            "n": 636,
+            "point_pct": 95.6,
+            "ci95_lo": 93.87,
+            "ci95_hi": 97.17,
+            "delta_vs_ref_pct": 3.3,
+            "delta_ci95_lo": 1.73,
+            "delta_ci95_hi": 5.03,
+            "p_value_vs_ref": 4.923344e-05
+          },
+          "Local 8B Instruct LLM (FP16)": {
+            "n": 636,
+            "point_pct": 92.45,
+            "ci95_lo": 90.25,
+            "ci95_hi": 94.5,
+            "delta_vs_ref_pct": 6.45,
+            "delta_ci95_lo": 4.56,
+            "delta_ci95_hi": 8.33,
+            "p_value_vs_ref": 9.094947e-13
+          }
+        }
+      },
+      "panel_2e_junk_balanced_977": {
+        "panel_name": "chart1_2e_beyond_junk977_balanced",
+        "n": 977,
+        "metric_type": "balanced",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 977,
+            "point_pct": 99.23,
+            "ci95_lo": 97.69,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 977,
+            "point_pct": 99.23,
+            "ci95_lo": 97.69,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Google Gemini Flash": {
+            "n": 977,
+            "point_pct": 99.18,
+            "ci95_lo": 97.53,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.05,
+            "delta_ci95_lo": -2.25,
+            "delta_ci95_hi": 2.36,
+            "p_value_vs_ref": 1.0
+          },
+          "Anthropic Claude Haiku 4.5": {
+            "n": 977,
+            "point_pct": 93.09,
+            "ci95_lo": 90.56,
+            "ci95_hi": 95.12,
+            "delta_vs_ref_pct": 6.14,
+            "delta_ci95_lo": 3.39,
+            "delta_ci95_hi": 9.0,
+            "p_value_vs_ref": 8.046381e-29
+          },
+          "OpenAI GPT (Fast Tier)": {
+            "n": 977,
+            "point_pct": 50.0,
+            "ci95_lo": 50.0,
+            "ci95_hi": 50.0,
+            "delta_vs_ref_pct": 49.23,
+            "delta_ci95_lo": 47.69,
+            "delta_ci95_hi": 50.0,
+            "p_value_vs_ref": 1.084202e-19
+          },
+          "Local 8B Instruct LLM (FP16)": {
+            "n": 977,
+            "point_pct": 97.91,
+            "ci95_lo": 95.5,
+            "ci95_hi": 99.62,
+            "delta_vs_ref_pct": 1.32,
+            "delta_ci95_lo": -1.15,
+            "delta_ci95_hi": 4.01,
+            "p_value_vs_ref": 0.003417969
+          }
+        }
+      },
+      "panel_2f_swarm_public_757": {
+        "panel_name": "chart1_2f_swarm_public_757",
+        "n": 757,
+        "metric_type": "auroc",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 757,
+            "point_pct": 92.42,
+            "ci95_lo": 90.55,
+            "ci95_hi": 94.13,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 757,
+            "point_pct": 92.42,
+            "ci95_lo": 90.55,
+            "ci95_hi": 94.13,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Google Gemini Flash": {
+            "n": 757,
+            "point_pct": 89.2,
+            "ci95_lo": 86.89,
+            "ci95_hi": 91.42,
+            "delta_vs_ref_pct": 3.22,
+            "delta_ci95_lo": 0.32,
+            "delta_ci95_hi": 6.1,
+            "p_value_vs_ref": 2.227484e-06
+          },
+          "Anthropic Claude Haiku 4.5": {
+            "n": 757,
+            "point_pct": 89.76,
+            "ci95_lo": 87.53,
+            "ci95_hi": 91.94,
+            "delta_vs_ref_pct": 2.66,
+            "delta_ci95_lo": -0.16,
+            "delta_ci95_hi": 5.47,
+            "p_value_vs_ref": 4.115658e-10
+          },
+          "OpenAI GPT (Fast Tier)": {
+            "n": 757,
+            "point_pct": 89.82,
+            "ci95_lo": 87.51,
+            "ci95_hi": 91.93,
+            "delta_vs_ref_pct": 2.6,
+            "delta_ci95_lo": -0.26,
+            "delta_ci95_hi": 5.47,
+            "p_value_vs_ref": 6.473227e-07
+          },
+          "Local 8B Instruct LLM (FP16)": {
+            "n": 757,
+            "point_pct": 66.32,
+            "ci95_lo": 62.34,
+            "ci95_hi": 70.17,
+            "delta_vs_ref_pct": 26.1,
+            "delta_ci95_lo": 21.73,
+            "delta_ci95_hi": 30.6,
+            "p_value_vs_ref": 1.035307e-81
+          }
+        }
+      },
+      "panel_2f_swarm_warehouse_10278": {
+        "panel_name": "chart1_2f_swarm_warehouse_10278",
+        "n": 10278,
+        "metric_type": "auroc",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 10278,
+            "point_pct": 96.83,
+            "ci95_lo": 96.52,
+            "ci95_hi": 97.12,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger 4-Way Priors": {
+            "n": 10278,
+            "point_pct": 86.64,
+            "ci95_lo": 85.91,
+            "ci95_hi": 87.36,
+            "delta_vs_ref_pct": 10.19,
+            "delta_ci95_lo": 9.39,
+            "delta_ci95_hi": 10.99,
+            "p_value_vs_ref": 0.0
+          },
+          "Raw Seeder Count": {
+            "n": 10278,
+            "point_pct": 53.02,
+            "ci95_lo": 51.88,
+            "ci95_hi": 54.22,
+            "delta_vs_ref_pct": 43.81,
+            "delta_ci95_lo": 42.57,
+            "delta_ci95_hi": 45.0,
+            "p_value_vs_ref": 0.0
+          }
+        }
+      }
+    },
+    "armiger_vs_llms_cost_comparison.png": {
+      "sha256": "3cf46fd59817d3bffafce1f4f5a15379ffef7bf779b8d4b40b866a8d9671eff4",
+      "models": [
+        "Armiger (8.3 MB M4 Pro CPU INT8)",
+        "Armiger Ultra (M4 Pro / RTX GPU FP32)",
+        "Local 8B Instruct LLM (FP16)",
+        "Google Gemini Flash",
+        "Cheap OpenAI GPT (Fast Tier)",
+        "Anthropic Claude Haiku 4.5"
+      ],
+      "batched_usd_per_1m": [
+        0.002,
+        0.004,
+        1.85,
+        94.9,
+        127.3,
+        712.0
+      ],
+      "realtime_usd_per_1m": [
+        0.002,
+        0.004,
+        18.0,
+        147.0,
+        220.5,
+        1220.0
+      ]
+    },
+    "armiger_vs_torrent_classifiers_6dims.png": {
+      "sha256": "e6be359c5cc980b4fe30810d4f2f5b8b202bd3fca6f2a4a33ae0727c5de2f010",
+      "panel_1_category_11class_oct15": {
+        "panel_name": "chart3_1_oct15_cat11",
+        "n": 2835,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 2835,
+            "point_pct": 95.49,
+            "ci95_lo": 94.71,
+            "ci95_hi": 96.23,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 2835,
+            "point_pct": 95.49,
+            "ci95_lo": 94.71,
+            "ci95_hi": 96.23,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "MIMMO BERT (360M)": {
+            "n": 2835,
+            "point_pct": 72.24,
+            "ci95_lo": 70.58,
+            "ci95_hi": 73.86,
+            "delta_vs_ref_pct": 23.25,
+            "delta_ci95_lo": 21.62,
+            "delta_ci95_hi": 24.9,
+            "p_value_vs_ref": 2.797454e-162
+          },
+          "MIMMO Cascade": {
+            "n": 2835,
+            "point_pct": 71.32,
+            "ci95_lo": 69.63,
+            "ci95_hi": 72.95,
+            "delta_vs_ref_pct": 24.16,
+            "delta_ci95_lo": 22.5,
+            "delta_ci95_hi": 25.86,
+            "p_value_vs_ref": 7.860859e-169
+          },
+          "RTN (rank-torrent-name)": {
+            "n": 2835,
+            "point_pct": 53.58,
+            "ci95_lo": 51.78,
+            "ci95_hi": 55.41,
+            "delta_vs_ref_pct": 41.9,
+            "delta_ci95_lo": 40.07,
+            "delta_ci95_hi": 43.77,
+            "p_value_vs_ref": 0.0
+          },
+          "PTT / Parsett": {
+            "n": 2835,
+            "point_pct": 53.58,
+            "ci95_lo": 51.78,
+            "ci95_hi": 55.41,
+            "delta_vs_ref_pct": 41.9,
+            "delta_ci95_lo": 40.07,
+            "delta_ci95_hi": 43.77,
+            "p_value_vs_ref": 0.0
+          },
+          "GuessIt": {
+            "n": 2835,
+            "point_pct": 38.69,
+            "ci95_lo": 36.93,
+            "ci95_hi": 40.46,
+            "delta_vs_ref_pct": 56.79,
+            "delta_ci95_lo": 54.96,
+            "delta_ci95_hi": 58.62,
+            "p_value_vs_ref": 0.0
+          },
+          "PTN (parse-torrent-title)": {
+            "n": 2835,
+            "point_pct": 35.59,
+            "ci95_lo": 33.83,
+            "ci95_hi": 37.35,
+            "delta_vs_ref_pct": 59.89,
+            "delta_ci95_lo": 58.06,
+            "delta_ci95_hi": 61.73,
+            "p_value_vs_ref": 0.0
+          },
+          "Anitomy": {
+            "n": 2835,
+            "point_pct": 33.4,
+            "ci95_lo": 31.68,
+            "ci95_hi": 35.13,
+            "delta_vs_ref_pct": 62.08,
+            "delta_ci95_lo": 60.25,
+            "delta_ci95_hi": 63.88,
+            "p_value_vs_ref": 0.0
+          },
+          "Bitmagnet Built-In": {
+            "n": 2835,
+            "point_pct": 35.17,
+            "ci95_lo": 33.47,
+            "ci95_hi": 36.9,
+            "delta_vs_ref_pct": 60.32,
+            "delta_ci95_lo": 58.52,
+            "delta_ci95_hi": 62.12,
+            "p_value_vs_ref": 0.0
+          }
+        }
+      },
+      "panel_1_video_mvtv_oct15": {
+        "panel_name": "chart3_1_oct15_video_mvtv",
+        "n": 1296,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 1296,
+            "point_pct": 97.3,
+            "ci95_lo": 96.37,
+            "ci95_hi": 98.15,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 1296,
+            "point_pct": 97.3,
+            "ci95_lo": 96.37,
+            "ci95_hi": 98.15,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "MIMMO BERT (360M)": {
+            "n": 1296,
+            "point_pct": 76.0,
+            "ci95_lo": 73.61,
+            "ci95_hi": 78.32,
+            "delta_vs_ref_pct": 21.3,
+            "delta_ci95_lo": 18.9,
+            "delta_ci95_hi": 23.77,
+            "p_value_vs_ref": 1.427447e-63
+          },
+          "MIMMO Cascade": {
+            "n": 1296,
+            "point_pct": 76.08,
+            "ci95_lo": 73.69,
+            "ci95_hi": 78.4,
+            "delta_vs_ref_pct": 21.22,
+            "delta_ci95_lo": 18.83,
+            "delta_ci95_hi": 23.69,
+            "p_value_vs_ref": 2.667039e-63
+          },
+          "RTN (rank-torrent-name)": {
+            "n": 1296,
+            "point_pct": 81.64,
+            "ci95_lo": 79.48,
+            "ci95_hi": 83.72,
+            "delta_vs_ref_pct": 15.66,
+            "delta_ci95_lo": 13.5,
+            "delta_ci95_hi": 17.82,
+            "p_value_vs_ref": 4.447751e-45
+          },
+          "PTT / Parsett": {
+            "n": 1296,
+            "point_pct": 81.64,
+            "ci95_lo": 79.48,
+            "ci95_hi": 83.72,
+            "delta_vs_ref_pct": 15.66,
+            "delta_ci95_lo": 13.5,
+            "delta_ci95_hi": 17.82,
+            "p_value_vs_ref": 4.447751e-45
+          },
+          "GuessIt": {
+            "n": 1296,
+            "point_pct": 84.65,
+            "ci95_lo": 82.64,
+            "ci95_hi": 86.57,
+            "delta_vs_ref_pct": 12.65,
+            "delta_ci95_lo": 10.65,
+            "delta_ci95_hi": 14.66,
+            "p_value_vs_ref": 2.56753e-35
+          },
+          "PTN (parse-torrent-title)": {
+            "n": 1296,
+            "point_pct": 77.85,
+            "ci95_lo": 75.54,
+            "ci95_hi": 80.09,
+            "delta_vs_ref_pct": 19.44,
+            "delta_ci95_lo": 17.05,
+            "delta_ci95_hi": 21.84,
+            "p_value_vs_ref": 1.163065e-57
+          },
+          "Anitomy": {
+            "n": 1296,
+            "point_pct": 73.07,
+            "ci95_lo": 70.6,
+            "ci95_hi": 75.46,
+            "delta_vs_ref_pct": 24.23,
+            "delta_ci95_lo": 21.68,
+            "delta_ci95_hi": 26.77,
+            "p_value_vs_ref": 5.732874e-76
+          },
+          "Bitmagnet Built-In": {
+            "n": 1296,
+            "point_pct": 43.21,
+            "ci95_lo": 40.51,
+            "ci95_hi": 45.91,
+            "delta_vs_ref_pct": 54.09,
+            "delta_ci95_lo": 51.23,
+            "delta_ci95_hi": 56.87,
+            "p_value_vs_ref": 8.363314e-201
+          }
+        }
+      },
+      "panel_2_catalog_matching_oct15": {
+        "panel_name": "chart3_2_oct15_catalog_matching",
+        "n": 1296,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 1296,
+            "point_pct": 96.53,
+            "ci95_lo": 95.52,
+            "ci95_hi": 97.53,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 1296,
+            "point_pct": 96.53,
+            "ci95_lo": 95.52,
+            "ci95_hi": 97.53,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "MIMMO BERT (360M)": {
+            "n": 1296,
+            "point_pct": 60.26,
+            "ci95_lo": 57.56,
+            "ci95_hi": 62.96,
+            "delta_vs_ref_pct": 36.27,
+            "delta_ci95_lo": 33.49,
+            "delta_ci95_hi": 39.12,
+            "p_value_vs_ref": 1.578863e-117
+          },
+          "MIMMO Cascade": {
+            "n": 1296,
+            "point_pct": 60.34,
+            "ci95_lo": 57.56,
+            "ci95_hi": 62.96,
+            "delta_vs_ref_pct": 36.19,
+            "delta_ci95_lo": 33.33,
+            "delta_ci95_hi": 39.04,
+            "p_value_vs_ref": 3.028483e-117
+          },
+          "RTN (rank-torrent-name)": {
+            "n": 1296,
+            "point_pct": 80.48,
+            "ci95_lo": 78.24,
+            "ci95_hi": 82.64,
+            "delta_vs_ref_pct": 16.05,
+            "delta_ci95_lo": 13.81,
+            "delta_ci95_hi": 18.29,
+            "p_value_vs_ref": 7.158345e-45
+          },
+          "PTT / Parsett": {
+            "n": 1296,
+            "point_pct": 80.48,
+            "ci95_lo": 78.24,
+            "ci95_hi": 82.64,
+            "delta_vs_ref_pct": 16.05,
+            "delta_ci95_lo": 13.81,
+            "delta_ci95_hi": 18.29,
+            "p_value_vs_ref": 7.158345e-45
+          },
+          "GuessIt": {
+            "n": 1296,
+            "point_pct": 84.03,
+            "ci95_lo": 82.02,
+            "ci95_hi": 85.96,
+            "delta_vs_ref_pct": 12.5,
+            "delta_ci95_lo": 10.42,
+            "delta_ci95_hi": 14.58,
+            "p_value_vs_ref": 7.451219e-32
+          },
+          "PTN (parse-torrent-title)": {
+            "n": 1296,
+            "point_pct": 77.62,
+            "ci95_lo": 75.31,
+            "ci95_hi": 79.86,
+            "delta_vs_ref_pct": 18.9,
+            "delta_ci95_lo": 16.51,
+            "delta_ci95_hi": 21.37,
+            "p_value_vs_ref": 3.559008e-51
+          },
+          "Anitomy": {
+            "n": 1296,
+            "point_pct": 72.76,
+            "ci95_lo": 70.29,
+            "ci95_hi": 75.15,
+            "delta_vs_ref_pct": 23.77,
+            "delta_ci95_lo": 21.22,
+            "delta_ci95_hi": 26.31,
+            "p_value_vs_ref": 7.077119e-70
+          },
+          "Bitmagnet Built-In": {
+            "n": 1296,
+            "point_pct": 43.21,
+            "ci95_lo": 40.51,
+            "ci95_hi": 45.91,
+            "delta_vs_ref_pct": 53.32,
+            "delta_ci95_lo": 50.54,
+            "delta_ci95_hi": 56.1,
+            "p_value_vs_ref": 7.866753e-198
+          }
+        }
+      },
+      "panel_3_audio_strict_oct15": {
+        "panel_name": "chart3_3_oct15_audio_strict545",
+        "n": 545,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 545,
+            "point_pct": 97.8,
+            "ci95_lo": 96.51,
+            "ci95_hi": 98.9,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 545,
+            "point_pct": 97.8,
+            "ci95_lo": 96.51,
+            "ci95_hi": 98.9,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "RTN (rank-torrent-name)": {
+            "n": 545,
+            "point_pct": 93.76,
+            "ci95_lo": 91.74,
+            "ci95_hi": 95.78,
+            "delta_vs_ref_pct": 4.04,
+            "delta_ci95_lo": 1.83,
+            "delta_ci95_hi": 6.24,
+            "p_value_vs_ref": 0.0006795483
+          },
+          "PTT / Parsett": {
+            "n": 545,
+            "point_pct": 93.76,
+            "ci95_lo": 91.74,
+            "ci95_hi": 95.78,
+            "delta_vs_ref_pct": 4.04,
+            "delta_ci95_lo": 1.83,
+            "delta_ci95_hi": 6.24,
+            "p_value_vs_ref": 0.0006795483
+          },
+          "GuessIt": {
+            "n": 545,
+            "point_pct": 94.86,
+            "ci95_lo": 93.03,
+            "ci95_hi": 96.7,
+            "delta_vs_ref_pct": 2.94,
+            "delta_ci95_lo": 0.92,
+            "delta_ci95_hi": 4.95,
+            "p_value_vs_ref": 0.009041185
+          },
+          "PTN (parse-torrent-title)": {
+            "n": 545,
+            "point_pct": 93.21,
+            "ci95_lo": 91.01,
+            "ci95_hi": 95.23,
+            "delta_vs_ref_pct": 4.59,
+            "delta_ci95_lo": 2.39,
+            "delta_ci95_hi": 6.97,
+            "p_value_vs_ref": 0.0001701552
+          },
+          "Anitomy": {
+            "n": 545,
+            "point_pct": 90.46,
+            "ci95_lo": 88.07,
+            "ci95_hi": 92.84,
+            "delta_vs_ref_pct": 7.34,
+            "delta_ci95_lo": 4.77,
+            "delta_ci95_hi": 9.91,
+            "p_value_vs_ref": 4.688184e-08
+          },
+          "Bitmagnet Built-In": {
+            "n": 545,
+            "point_pct": 88.26,
+            "ci95_lo": 85.5,
+            "ci95_hi": 90.83,
+            "delta_vs_ref_pct": 9.54,
+            "delta_ci95_lo": 6.79,
+            "delta_ci95_hi": 12.29,
+            "p_value_vs_ref": 2.383493e-11
+          }
+        }
+      },
+      "panel_4_anime_oct15": {
+        "panel_name": "chart3_4_oct15_anime507",
+        "n": 507,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 507,
+            "point_pct": 99.61,
+            "ci95_lo": 99.01,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 507,
+            "point_pct": 99.61,
+            "ci95_lo": 99.01,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          }
+        }
+      },
+      "panel_4_anime_dub_tc2000": {
+        "panel_name": "chart3_4_tc2000_anime_dub",
+        "n": 2000,
+        "metric_type": "mean",
+        "reference_model": "RTN (rank-torrent-name)",
+        "models": {
+          "RTN (rank-torrent-name)": {
+            "n": 2000,
+            "point_pct": 77.65,
+            "ci95_lo": 75.75,
+            "ci95_hi": 79.45,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "PTT / Parsett": {
+            "n": 2000,
+            "point_pct": 77.65,
+            "ci95_lo": 75.75,
+            "ci95_hi": 79.45,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "GuessIt": {
+            "n": 2000,
+            "point_pct": 78.8,
+            "ci95_lo": 76.95,
+            "ci95_hi": 80.55,
+            "delta_vs_ref_pct": -1.15,
+            "delta_ci95_lo": -2.45,
+            "delta_ci95_hi": 0.15,
+            "p_value_vs_ref": 0.09792971
+          },
+          "PTN (parse-torrent-title)": {
+            "n": 2000,
+            "point_pct": 68.65,
+            "ci95_lo": 66.6,
+            "ci95_hi": 70.65,
+            "delta_vs_ref_pct": 9.0,
+            "delta_ci95_lo": 7.15,
+            "delta_ci95_hi": 10.85,
+            "p_value_vs_ref": 7.57291e-21
+          },
+          "Anitomy": {
+            "n": 2000,
+            "point_pct": 64.55,
+            "ci95_lo": 62.45,
+            "ci95_hi": 66.6,
+            "delta_vs_ref_pct": 13.1,
+            "delta_ci95_lo": 11.2,
+            "delta_ci95_hi": 15.05,
+            "p_value_vs_ref": 4.440189e-40
+          }
+        }
+      },
+      "panel_5_adult_oct15": {
+        "panel_name": "chart3_5_oct15_adult2781",
+        "n": 2781,
+        "metric_type": "mean",
+        "reference_model": "Armiger Ultra (Fair Hybrid)",
+        "models": {
+          "Armiger Ultra (Fair Hybrid)": {
+            "n": 2781,
+            "point_pct": 98.53,
+            "ci95_lo": 98.06,
+            "ci95_hi": 98.96,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger (8.3 MB INT8 + Plugins)": {
+            "n": 2781,
+            "point_pct": 98.49,
+            "ci95_lo": 98.02,
+            "ci95_hi": 98.92,
+            "delta_vs_ref_pct": 0.04,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.11,
+            "p_value_vs_ref": 1.0
+          },
+          "MIMMO BERT (360M)": {
+            "n": 2781,
+            "point_pct": 91.05,
+            "ci95_lo": 89.93,
+            "ci95_hi": 92.09,
+            "delta_vs_ref_pct": 7.48,
+            "delta_ci95_lo": 6.44,
+            "delta_ci95_hi": 8.59,
+            "p_value_vs_ref": 2.280742e-45
+          },
+          "MIMMO Cascade": {
+            "n": 2781,
+            "point_pct": 89.68,
+            "ci95_lo": 88.53,
+            "ci95_hi": 90.79,
+            "delta_vs_ref_pct": 8.85,
+            "delta_ci95_lo": 7.73,
+            "delta_ci95_hi": 10.03,
+            "p_value_vs_ref": 1.795157e-55
+          },
+          "RTN (rank-torrent-name)": {
+            "n": 2781,
+            "point_pct": 79.0,
+            "ci95_lo": 77.45,
+            "ci95_hi": 80.55,
+            "delta_vs_ref_pct": 19.53,
+            "delta_ci95_lo": 17.98,
+            "delta_ci95_hi": 21.07,
+            "p_value_vs_ref": 2.877898e-138
+          },
+          "PTT / Parsett": {
+            "n": 2781,
+            "point_pct": 79.0,
+            "ci95_lo": 77.45,
+            "ci95_hi": 80.55,
+            "delta_vs_ref_pct": 19.53,
+            "delta_ci95_lo": 17.98,
+            "delta_ci95_hi": 21.07,
+            "p_value_vs_ref": 2.877898e-138
+          },
+          "Bitmagnet Built-In": {
+            "n": 2781,
+            "point_pct": 76.73,
+            "ci95_lo": 75.19,
+            "ci95_hi": 78.32,
+            "delta_vs_ref_pct": 21.79,
+            "delta_ci95_lo": 20.17,
+            "delta_ci95_hi": 23.37,
+            "p_value_vs_ref": 1.549894e-154
+          }
+        }
+      },
+      "panel_6a_junk_oct15": {
+        "panel_name": "chart3_6a_oct15_junk2170",
+        "n": 2170,
+        "metric_type": "balanced",
+        "reference_model": "Armiger Ultra",
+        "models": {
+          "Armiger Ultra": {
+            "n": 2170,
+            "point_pct": 100.0,
+            "ci95_lo": 100.0,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Armiger INT8": {
+            "n": 2170,
+            "point_pct": 100.0,
+            "ci95_lo": 100.0,
+            "ci95_hi": 100.0,
+            "delta_vs_ref_pct": 0.0,
+            "delta_ci95_lo": 0.0,
+            "delta_ci95_hi": 0.0,
+            "p_value_vs_ref": 1.0
+          },
+          "Bitmagnet": {
+            "n": 2170,
+            "point_pct": 50.0,
+            "ci95_lo": 50.0,
+            "ci95_hi": 50.0,
+            "delta_vs_ref_pct": 50.0,
+            "delta_ci95_lo": 50.0,
+            "delta_ci95_hi": 50.0,
+            "p_value_vs_ref": 1.0
+          },
+          "RTN Filter": {
+            "n": 2170,
+            "point_pct": 49.29,
+            "ci95_lo": 49.03,
+            "ci95_hi": 49.52,
+            "delta_vs_ref_pct": 50.71,
+            "delta_ci95_lo": 50.48,
+            "delta_ci95_hi": 50.97,
+            "p_value_vs_ref": 4.656613e-10
+          }
+        }
+      }
+    },
+    "armiger_categorical_breakdown.png": {
+      "sha256": "1a77a64340f7e05af318105d83270b29396450d01f22f71cffdf808b45e10d98",
+      "left_oct15_confirmation_n2835": {
+        "Audiobook": {
+          "n": 95,
+          "armiger_ultra_pct": 97.89,
+          "armiger_int8_pct": 97.89,
+          "mimmo_bert_pct": 0.0,
+          "bitmagnet_pct": 9.47
+        },
+        "Adult / XXX": {
+          "n": 1044,
+          "armiger_ultra_pct": 97.8,
+          "armiger_int8_pct": 97.8,
+          "mimmo_bert_pct": 95.5,
+          "bitmagnet_pct": 39.37
+        },
+        "TV Show": {
+          "n": 601,
+          "armiger_ultra_pct": 97.5,
+          "armiger_int8_pct": 97.5,
+          "mimmo_bert_pct": 58.4,
+          "bitmagnet_pct": 28.62
+        },
+        "Movie": {
+          "n": 695,
+          "armiger_ultra_pct": 97.12,
+          "armiger_int8_pct": 97.12,
+          "mimmo_bert_pct": 78.85,
+          "bitmagnet_pct": 55.83
+        },
+        "Software": {
+          "n": 32,
+          "armiger_ultra_pct": 93.75,
+          "armiger_int8_pct": 93.75,
+          "mimmo_bert_pct": 59.38,
+          "bitmagnet_pct": 15.62
+        },
+        "Music": {
+          "n": 140,
+          "armiger_ultra_pct": 90.71,
+          "armiger_int8_pct": 90.71,
+          "mimmo_bert_pct": 77.86,
+          "bitmagnet_pct": 7.86
+        },
+        "Game": {
+          "n": 61,
+          "armiger_ultra_pct": 90.16,
+          "armiger_int8_pct": 90.16,
+          "mimmo_bert_pct": 0.0,
+          "bitmagnet_pct": 0.0
+        },
+        "Ebook": {
+          "n": 25,
+          "armiger_ultra_pct": 88.0,
+          "armiger_int8_pct": 88.0,
+          "mimmo_bert_pct": 80.0,
+          "bitmagnet_pct": 4.0
+        },
+        "Course": {
+          "n": 33,
+          "armiger_ultra_pct": 81.82,
+          "armiger_int8_pct": 81.82,
+          "mimmo_bert_pct": 0.0,
+          "bitmagnet_pct": 0.0
+        },
+        "Comic": {
+          "n": 99,
+          "armiger_ultra_pct": 66.67,
+          "armiger_int8_pct": 66.67,
+          "mimmo_bert_pct": 0.0,
+          "bitmagnet_pct": 0.0
+        }
+      },
+      "right_beyond_confirmation_n1025_loto": {
+        "Audiobook": {
+          "n": 75,
+          "armiger_ultra_pct": 100.0,
+          "armiger_int8_pct": 100.0,
+          "gpt_noncirc_pct": 98.67,
+          "gemini_noncirc_pct": 98.0
+        },
+        "Ebook": {
+          "n": 125,
+          "armiger_ultra_pct": 98.4,
+          "armiger_int8_pct": 98.4,
+          "gpt_noncirc_pct": 96.0,
+          "gemini_noncirc_pct": 96.8
+        },
+        "Comic": {
+          "n": 120,
+          "armiger_ultra_pct": 98.33,
+          "armiger_int8_pct": 98.33,
+          "gpt_noncirc_pct": 96.67,
+          "gemini_noncirc_pct": 95.0
+        },
+        "Movie": {
+          "n": 95,
+          "armiger_ultra_pct": 96.84,
+          "armiger_int8_pct": 96.84,
+          "gpt_noncirc_pct": 94.21,
+          "gemini_noncirc_pct": 92.63
+        },
+        "TV Show": {
+          "n": 136,
+          "armiger_ultra_pct": 96.32,
+          "armiger_int8_pct": 96.32,
+          "gpt_noncirc_pct": 97.79,
+          "gemini_noncirc_pct": 93.75
+        },
+        "Game": {
+          "n": 135,
+          "armiger_ultra_pct": 96.3,
+          "armiger_int8_pct": 96.3,
+          "gpt_noncirc_pct": 98.52,
+          "gemini_noncirc_pct": 98.52
+        },
+        "Software": {
+          "n": 37,
+          "armiger_ultra_pct": 94.59,
+          "armiger_int8_pct": 94.59,
+          "gpt_noncirc_pct": 97.3,
+          "gemini_noncirc_pct": 77.03
+        },
+        "Course": {
+          "n": 100,
+          "armiger_ultra_pct": 92.0,
+          "armiger_int8_pct": 92.0,
+          "gpt_noncirc_pct": 95.5,
+          "gemini_noncirc_pct": 97.5
+        },
+        "Adult / XXX": {
+          "n": 174,
+          "armiger_ultra_pct": 91.95,
+          "armiger_int8_pct": 91.95,
+          "gpt_noncirc_pct": 94.83,
+          "gemini_noncirc_pct": 95.69
+        },
+        "Music": {
+          "n": 12,
+          "armiger_ultra_pct": 83.33,
+          "armiger_int8_pct": 83.33,
+          "gpt_noncirc_pct": 100.0,
+          "gemini_noncirc_pct": 100.0
+        }
+      }
+    }
+  },
+  "five_split_category_summary": {
+    "oct15_confirmation": {
+      "panel_name": "five_split_oct15",
+      "n": 2835,
+      "metric_type": "mean",
+      "reference_model": "armiger_ultra_hyb",
+      "models": {
+        "armiger_ultra_hyb": {
+          "n": 2835,
+          "point_pct": 95.49,
+          "ci95_lo": 94.71,
+          "ci95_hi": 96.23,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_ultra_raw": {
+          "n": 2835,
+          "point_pct": 95.03,
+          "ci95_lo": 94.22,
+          "ci95_hi": 95.84,
+          "delta_vs_ref_pct": 0.46,
+          "delta_ci95_lo": 0.14,
+          "delta_ci95_hi": 0.78,
+          "p_value_vs_ref": 0.00719738
+        },
+        "armiger_int8_hyb": {
+          "n": 2835,
+          "point_pct": 95.49,
+          "ci95_lo": 94.71,
+          "ci95_hi": 96.23,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_int8_raw": {
+          "n": 2835,
+          "point_pct": 95.06,
+          "ci95_lo": 94.25,
+          "ci95_hi": 95.87,
+          "delta_vs_ref_pct": 0.42,
+          "delta_ci95_lo": 0.14,
+          "delta_ci95_hi": 0.74,
+          "p_value_vs_ref": 0.01181793
+        }
+      }
+    },
+    "fresh_confirmation": {
+      "panel_name": "five_split_fresh",
+      "n": 1402,
+      "metric_type": "mean",
+      "reference_model": "armiger_ultra_hyb",
+      "models": {
+        "armiger_ultra_hyb": {
+          "n": 1402,
+          "point_pct": 94.58,
+          "ci95_lo": 93.37,
+          "ci95_hi": 95.72,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_ultra_raw": {
+          "n": 1402,
+          "point_pct": 94.51,
+          "ci95_lo": 93.3,
+          "ci95_hi": 95.65,
+          "delta_vs_ref_pct": 0.07,
+          "delta_ci95_lo": -0.21,
+          "delta_ci95_hi": 0.36,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_int8_hyb": {
+          "n": 1402,
+          "point_pct": 94.58,
+          "ci95_lo": 93.37,
+          "ci95_hi": 95.72,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_int8_raw": {
+          "n": 1402,
+          "point_pct": 94.51,
+          "ci95_lo": 93.3,
+          "ci95_hi": 95.65,
+          "delta_vs_ref_pct": 0.07,
+          "delta_ci95_lo": -0.21,
+          "delta_ci95_hi": 0.36,
+          "p_value_vs_ref": 1.0
+        }
+      }
+    },
+    "beyond_confirmation": {
+      "panel_name": "five_split_beyond",
+      "n": 1025,
+      "metric_type": "mean",
+      "reference_model": "armiger_ultra_hyb",
+      "models": {
+        "armiger_ultra_hyb": {
+          "n": 1025,
+          "point_pct": 95.12,
+          "ci95_lo": 93.76,
+          "ci95_hi": 96.39,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_ultra_raw": {
+          "n": 1025,
+          "point_pct": 92.88,
+          "ci95_lo": 91.22,
+          "ci95_hi": 94.44,
+          "delta_vs_ref_pct": 2.24,
+          "delta_ci95_lo": 1.37,
+          "delta_ci95_hi": 3.22,
+          "p_value_vs_ref": 2.384186e-07
+        },
+        "armiger_int8_hyb": {
+          "n": 1025,
+          "point_pct": 95.12,
+          "ci95_lo": 93.76,
+          "ci95_hi": 96.39,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_int8_raw": {
+          "n": 1025,
+          "point_pct": 92.88,
+          "ci95_lo": 91.22,
+          "ci95_hi": 94.44,
+          "delta_vs_ref_pct": 2.24,
+          "delta_ci95_lo": 1.37,
+          "delta_ci95_hi": 3.22,
+          "p_value_vs_ref": 2.384186e-07
+        }
+      }
+    },
+    "tc_truespec_2000": {
+      "panel_name": "five_split_tc2000",
+      "n": 2000,
+      "metric_type": "mean",
+      "reference_model": "armiger_ultra_hyb",
+      "models": {
+        "armiger_ultra_hyb": {
+          "n": 2000,
+          "point_pct": 91.5,
+          "ci95_lo": 90.3,
+          "ci95_hi": 92.65,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_ultra_raw": {
+          "n": 2000,
+          "point_pct": 87.4,
+          "ci95_lo": 85.95,
+          "ci95_hi": 88.8,
+          "delta_vs_ref_pct": 4.1,
+          "delta_ci95_lo": 2.95,
+          "delta_ci95_hi": 5.25,
+          "p_value_vs_ref": 1.091317e-12
+        },
+        "armiger_int8_hyb": {
+          "n": 2000,
+          "point_pct": 91.4,
+          "ci95_lo": 90.2,
+          "ci95_hi": 92.55,
+          "delta_vs_ref_pct": 0.1,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.25,
+          "p_value_vs_ref": 0.5
+        },
+        "armiger_int8_raw": {
+          "n": 2000,
+          "point_pct": 87.3,
+          "ci95_lo": 85.85,
+          "ci95_hi": 88.7,
+          "delta_vs_ref_pct": 4.2,
+          "delta_ci95_lo": 3.05,
+          "delta_ci95_hi": 5.35,
+          "p_value_vs_ref": 4.246281e-13
+        }
+      }
+    },
+    "tc_truespec_multilang_3000": {
+      "panel_name": "five_split_tc3000",
+      "n": 3000,
+      "metric_type": "mean",
+      "reference_model": "armiger_ultra_hyb",
+      "models": {
+        "armiger_ultra_hyb": {
+          "n": 3000,
+          "point_pct": 98.47,
+          "ci95_lo": 98.0,
+          "ci95_hi": 98.9,
+          "delta_vs_ref_pct": 0.0,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.0,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_ultra_raw": {
+          "n": 3000,
+          "point_pct": 97.5,
+          "ci95_lo": 96.9,
+          "ci95_hi": 98.03,
+          "delta_vs_ref_pct": 0.97,
+          "delta_ci95_lo": 0.57,
+          "delta_ci95_hi": 1.4,
+          "p_value_vs_ref": 4.873598e-06
+        },
+        "armiger_int8_hyb": {
+          "n": 3000,
+          "point_pct": 98.43,
+          "ci95_lo": 97.97,
+          "ci95_hi": 98.87,
+          "delta_vs_ref_pct": 0.03,
+          "delta_ci95_lo": 0.0,
+          "delta_ci95_hi": 0.1,
+          "p_value_vs_ref": 1.0
+        },
+        "armiger_int8_raw": {
+          "n": 3000,
+          "point_pct": 97.43,
+          "ci95_lo": 96.83,
+          "ci95_hi": 97.97,
+          "delta_vs_ref_pct": 1.03,
+          "delta_ci95_lo": 0.63,
+          "delta_ci95_hi": 1.47,
+          "p_value_vs_ref": 1.636124e-06
+        }
+      }
+    }
+  }
+}

benchmarks/generate_canonical_charts.py

@@ -0,0 +1,1541 @@
+#!/usr/bin/env python3
+"""
+Deterministic, Statistically Rooted Benchmark & Chart Generation Pipeline
+for Armiger & Armiger Ultra.
+
+Enforces 4 hard statistical invariants before writing any chart:
+  1. Identical Denominator Lock (`assert_identical_denominator`)
+  2. Anti-Circularity Lock (`assert_non_circular_teacher_eval`)
+  3. Paired Uncertainty & Significance (10,000-resample paired bootstrap 95% CIs
+     with fixed seed 20261018 + exact two-sided McNemar / permutation p-values)
+  4. Cryptographic Provenance Manifest (`CHARTS_MANIFEST.json` + stripped PNG
+     chunks containing only `IHDR`, `IDAT`, `IEND`).
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import pathlib
+import struct
+import zlib
+from typing import Any, Dict, List, Optional, Tuple
+
+import math
+import numpy as np
+
+try:
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from matplotlib.gridspec import GridSpec
+    from matplotlib.patches import Patch
+    from PIL import Image
+    HAS_MATPLOTLIB = True
+except ImportError:
+    matplotlib = None  # type: ignore[assignment]
+    plt = None  # type: ignore[assignment]
+    GridSpec = None  # type: ignore[assignment]
+    Patch = None  # type: ignore[assignment]
+    Image = None  # type: ignore[assignment]
+    HAS_MATPLOTLIB = False
+
+BOOTSTRAP_SEED = 20261018
+BOOTSTRAP_RESAMPLES = 10000
+
+BG_CANVAS = "#0D1117"
+BG_PANEL = "#161B22"
+BG_HIGHLIGHT = "#0F2922"
+BORDER_COLOR = "#30363D"
+GRID_COLOR = "#21262D"
+TEXT_MAIN = "#F0F6FC"
+TEXT_SUB = "#8B949E"
+TEXT_MUTED = "#6E7681"
+
+C_ULTRA = "#10B981"
+C_ULTRA_EDGE = "#34D399"
+C_INT8 = "#3B82F6"
+C_INT8_EDGE = "#60A5FA"
+C_GEMINI = "#F59E0B"
+C_CLAUDE = "#F97316"
+C_GPT = "#38BDF8"
+C_VINCI = "#A855F7"
+C_ERR = "#E2E8F0"
+
+TEACHER_MODELS = {
+    "OpenAI GPT (Fast Tier)",
+    "Google Gemini Flash",
+    "Anthropic Claude Haiku 4.5",
+}
+
+
+# ==============================================================================
+# 1. HARD STATISTICAL INVARIANT LOCKS
+# ==============================================================================
+def assert_identical_denominator(
+    panel_name: str,
+    vectors: Dict[str, np.ndarray],
+    expected_n: Optional[int] = None,
+) -> int:
+    """Enforce that every model on a panel is evaluated on the exact same item count N
+    and valid-domain mask, with zero NaNs."""
+    if not vectors:
+        raise AssertionError(f"[{panel_name}] Empty vectors dictionary.")
+    lengths = {}
+    for model_name, vec in vectors.items():
+        arr = np.asarray(vec)
+        if arr.ndim != 1:
+            raise AssertionError(f"[{panel_name}] Model '{model_name}' vector must be 1D, got shape {arr.shape}.")
+        if np.isnan(arr).any():
+            raise AssertionError(f"[{panel_name}] Model '{model_name}' contains NaN values.")
+        lengths[model_name] = int(arr.shape[0])
+
+    unique_lengths = set(lengths.values())
+    if len(unique_lengths) != 1:
+        raise AssertionError(
+            f"[{panel_name}] Identical Denominator Lock violated! Mismatched N across models: {lengths}"
+        )
+    n_val = next(iter(unique_lengths))
+    if expected_n is not None and n_val != expected_n:
+        raise AssertionError(
+            f"[{panel_name}] Expected N={expected_n}, but got N={n_val} ({lengths})."
+        )
+    return n_val
+
+
+def assert_non_circular_teacher_eval(
+    model_name: str,
+    eval_mode: str,
+    self_vote_weight: float,
+    noncirc_vec: Optional[np.ndarray] = None,
+    circ_vec: Optional[np.ndarray] = None,
+) -> Dict[str, Any]:
+    """Enforce that teacher LLMs are never scored against a reference key in which
+    they cast a deciding self-vote."""
+    is_teacher = any(t in model_name for t in TEACHER_MODELS)
+    if is_teacher:
+        if self_vote_weight != 0.0 or eval_mode == "circular_majority":
+            raise AssertionError(
+                f"Anti-Circularity Lock violated for teacher '{model_name}': "
+                f"eval_mode='{eval_mode}', self_vote_weight={self_vote_weight} (must be 0.0)."
+            )
+        if eval_mode not in ("leave_one_teacher_out", "independent_ground_truth"):
+            raise AssertionError(
+                f"Invalid eval_mode '{eval_mode}' for teacher '{model_name}'."
+            )
+    info: Dict[str, Any] = {
+        "model_name": model_name,
+        "is_teacher": is_teacher,
+        "eval_mode": eval_mode,
+        "self_vote_weight": float(self_vote_weight),
+    }
+    if noncirc_vec is not None and circ_vec is not None:
+        assert_identical_denominator(f"anti_circ_{model_name}", {"noncirc": noncirc_vec, "circ": circ_vec})
+        nc_pct = float(np.mean(noncirc_vec) * 100.0)
+        c_pct = float(np.mean(circ_vec) * 100.0)
+        info["non_circular_pct"] = round(nc_pct, 2)
+        info["circular_self_vote_pct"] = round(c_pct, 2)
+        info["circularity_inflation_pp"] = round(c_pct - nc_pct, 2)
+    return info
+
+
+def exact_mcnemar_or_paired_p(vec_ref: np.ndarray, vec_mod: np.ndarray) -> float:
+    """Compute exact two-sided McNemar binomial p-value for binary vectors, or exact
+    paired sign-flip binomial test on discordant items for fractional LOTO vectors."""
+    diff = np.asarray(vec_ref, dtype=np.float64) - np.asarray(vec_mod, dtype=np.float64)
+    n_pos = int(np.sum(diff > 1e-6))
+    n_neg = int(np.sum(diff < -1e-6))
+    n_disc = n_pos + n_neg
+    if n_disc == 0:
+        return 1.0
+    m_min = min(n_pos, n_neg)
+    if 2 * m_min == n_disc:
+        return 1.0
+    tail_sum = sum(math.comb(n_disc, i) for i in range(m_min + 1))
+    return float(min(1.0, (2 * tail_sum) / (1 << n_disc)))
+
+
+def compute_auroc_pct(y_true: np.ndarray, scores: np.ndarray) -> float:
+    pos = scores[y_true == 1]
+    neg = scores[y_true == 0]
+    u = (pos[:, None] > neg[None, :]).sum() + 0.5 * (pos[:, None] == neg[None, :]).sum()
+    return float(100.0 * u / (len(pos) * len(neg)))
+
+
+def compute_paired_panel_stats(
+    panel_name: str,
+    vectors: Dict[str, np.ndarray],
+    ref_model: str,
+    expected_n: int,
+    metric_type: str = "mean",
+    y_true: Optional[np.ndarray] = None,
+    n_boot: int = BOOTSTRAP_RESAMPLES,
+    seed: int = BOOTSTRAP_SEED,
+) -> Dict[str, Any]:
+    """Compute point estimates, 10,000-resample paired bootstrap 95% CIs, paired deltas,
+    and McNemar / permutation p-values for all models in a panel."""
+    n_val = assert_identical_denominator(panel_name, vectors, expected_n=expected_n)
+    if ref_model not in vectors:
+        raise AssertionError(f"[{panel_name}] Reference model '{ref_model}' missing from vectors.")
+
+    rng = np.random.default_rng(seed)
+    model_names = list(vectors.keys())
+    mat = np.stack([np.asarray(vectors[m], dtype=np.float64) for m in model_names], axis=0)  # (M, N)
+
+    if metric_type == "mean":
+        # Exact integer-scaled dot product in float64 (bit-exact across ARM64 Accelerate & x86_64 OpenBLAS)
+        mat_int6 = np.round(mat * 6.0)
+        weights = rng.multinomial(n_val, np.full(n_val, 1.0 / n_val), size=n_boot).astype(np.float64)
+        boot_scores = (weights @ mat_int6.T) * (100.0 / (6.0 * n_val))
+        point_scores = {m: float(np.sum(np.round(np.asarray(vectors[m], dtype=np.float64) * 6.0)) * 100.0 / (6.0 * n_val)) for m in model_names}
+        item_correctness = {m: np.asarray(vectors[m], dtype=np.float64) for m in model_names}
+    elif metric_type == "balanced":
+        if y_true is None:
+            raise AssertionError(f"[{panel_name}] y_true required for metric_type='balanced'.")
+        y_arr = np.asarray(y_true)
+        pos_mask = (y_arr == 1)
+        neg_mask = (y_arr == 0)
+        n_pos = int(np.sum(pos_mask))
+        n_neg = int(np.sum(neg_mask))
+        pos_mat = (mat[:, pos_mask] == 1).astype(np.float64)
+        neg_mat = (mat[:, neg_mask] == 0).astype(np.float64)
+        w_pos = rng.multinomial(n_pos, np.full(n_pos, 1.0 / n_pos), size=n_boot).astype(np.float64)
+        w_neg = rng.multinomial(n_neg, np.full(n_neg, 1.0 / n_neg), size=n_boot).astype(np.float64)
+        boot_scores = 0.5 * ((w_pos @ pos_mat.T) * (100.0 / n_pos) + (w_neg @ neg_mat.T) * (100.0 / n_neg))
+        point_scores = {}
+        item_correctness = {}
+        for idx, m in enumerate(model_names):
+            sens = float(np.sum(pos_mat[idx]) * 100.0 / n_pos)
+            spec = float(np.sum(neg_mat[idx]) * 100.0 / n_neg)
+            point_scores[m] = 0.5 * (sens + spec)
+            item_corr = np.zeros(n_val, dtype=np.float64)
+            item_corr[pos_mask] = pos_mat[idx]
+            item_corr[neg_mask] = neg_mat[idx]
+            item_correctness[m] = item_corr
+    elif metric_type == "auroc":
+        if y_true is None:
+            raise AssertionError(f"[{panel_name}] y_true required for metric_type='auroc'.")
+        y_arr = np.asarray(y_true)
+        pos_idx = np.where(y_arr == 1)[0]
+        neg_idx = np.where(y_arr == 0)[0]
+        n_pos, n_neg = len(pos_idx), len(neg_idx)
+        # Exact integer-scaled placement counts in float64 (bit-exact across BLAS engines)
+        placement_int2 = np.zeros((len(model_names), n_val), dtype=np.float64)
+        placement_unit = np.zeros((len(model_names), n_val), dtype=np.float64)
+        point_scores = {}
+        for idx, m in enumerate(model_names):
+            s = mat[idx]
+            s_pos = s[pos_idx]
+            s_neg = s[neg_idx]
+            v10_int2 = 2.0 * (s_pos[:, None] > s_neg[None, :]).sum(axis=1) + (s_pos[:, None] == s_neg[None, :]).sum(axis=1)
+            v01_int2 = 2.0 * (s_pos[:, None] > s_neg[None, :]).sum(axis=0) + (s_pos[:, None] == s_neg[None, :]).sum(axis=0)
+            placement_int2[idx, pos_idx] = v10_int2
+            placement_int2[idx, neg_idx] = v01_int2
+            placement_unit[idx, pos_idx] = v10_int2 / (2.0 * n_neg)
+            placement_unit[idx, neg_idx] = v01_int2 / (2.0 * n_pos)
+            point_scores[m] = float(np.sum(v10_int2) * 100.0 / (2.0 * n_pos * n_neg))
+        w_pos = rng.multinomial(n_pos, np.full(n_pos, 1.0 / n_pos), size=n_boot).astype(np.float64)
+        w_neg = rng.multinomial(n_neg, np.full(n_neg, 1.0 / n_neg), size=n_boot).astype(np.float64)
+        pt_vec = np.array([point_scores[m] for m in model_names], dtype=np.float64)[None, :]
+        boot_scores = (
+            (w_pos @ placement_int2[:, pos_idx].T) * (100.0 / (2.0 * n_pos * n_neg))
+            + (w_neg @ placement_int2[:, neg_idx].T) * (100.0 / (2.0 * n_pos * n_neg))
+            - pt_vec
+        )
+        item_correctness = {m: placement_unit[idx] for idx, m in enumerate(model_names)}
+    else:
+        raise ValueError(f"Unknown metric_type: {metric_type}")
+
+    ref_idx = model_names.index(ref_model)
+    ref_boot = boot_scores[:, ref_idx]
+    ref_point = point_scores[ref_model]
+
+    results: Dict[str, Any] = {}
+    for idx, m in enumerate(model_names):
+        m_boot = boot_scores[:, idx]
+        ci_lo, ci_hi = np.percentile(m_boot, [2.5, 97.5])
+        delta_boot = ref_boot - m_boot
+        d_lo, d_hi = np.percentile(delta_boot, [2.5, 97.5])
+        p_val = 1.0 if m == ref_model else exact_mcnemar_or_paired_p(item_correctness[ref_model], item_correctness[m])
+        results[m] = {
+            "n": n_val,
+            "point_pct": round(point_scores[m], 2),
+            "ci95_lo": round(float(ci_lo), 2),
+            "ci95_hi": round(float(ci_hi), 2),
+            "delta_vs_ref_pct": round(ref_point - point_scores[m], 2),
+            "delta_ci95_lo": round(float(d_lo), 2),
+            "delta_ci95_hi": round(float(d_hi), 2),
+            "p_value_vs_ref": float(f"{p_val:.6e}"),
+        }
+    return {
+        "panel_name": panel_name,
+        "n": n_val,
+        "metric_type": metric_type,
+        "reference_model": ref_model,
+        "models": results,
+    }
+
+
+# ==============================================================================
+# 2. DETERMINISTIC PNG SERIALIZATION (STRIPPED TO IHDR, IDAT, IEND ONLY)
+# ==============================================================================
+def strip_png_chunks_to_canonical(png_bytes: bytes) -> bytes:
+    """Keep only IHDR, IDAT, and IEND chunks so the output PNG contains zero
+    timestamps, software tags, or host path metadata and is 100% deterministic."""
+    sig = b"\x89PNG\r\n\x1a\n"
+    if not png_bytes.startswith(sig):
+        raise ValueError("Invalid PNG header signature.")
+    pos = 8
+    out = bytearray(sig)
+    while pos < len(png_bytes):
+        length = struct.unpack(">I", png_bytes[pos:pos + 4])[0]
+        ctype = png_bytes[pos + 4:pos + 8]
+        chunk_data = png_bytes[pos + 8:pos + 8 + length]
+        crc = png_bytes[pos + 8 + length:pos + 12 + length]
+        pos += 12 + length
+        if ctype in (b"IHDR", b"IDAT", b"IEND"):
+            out.extend(struct.pack(">I", length))
+            out.extend(ctype)
+            out.extend(chunk_data)
+            out.extend(crc)
+    return bytes(out)
+
+
+def verify_png_chunks_clean(png_path: pathlib.Path) -> List[str]:
+    data = png_path.read_bytes()
+    sig = b"\x89PNG\r\n\x1a\n"
+    assert data.startswith(sig), f"{png_path} is not a valid PNG"
+    pos = 8
+    chunks: List[str] = []
+    while pos < len(data):
+        length = struct.unpack(">I", data[pos:pos + 4])[0]
+        ctype = data[pos + 4:pos + 8].decode("ascii", errors="replace")
+        chunks.append(ctype)
+        pos += 12 + length
+    for c in chunks:
+        if c not in ("IHDR", "IDAT", "IEND"):
+            raise AssertionError(f"{png_path} contains non-canonical PNG chunk: {c}")
+    return chunks
+
+
+def save_clean_rgb_png(fig: plt.Figure, out_path: pathlib.Path, dpi: int = 180) -> str:
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    buf = io.BytesIO()
+    fig.savefig(
+        buf,
+        format="png",
+        dpi=dpi,
+        bbox_inches="tight",
+        facecolor=BG_CANVAS,
+        edgecolor="none",
+        pad_inches=0.34,
+    )
+    plt.close(fig)
+    buf.seek(0)
+    with Image.open(buf) as im:
+        rgb = im.convert("RGB")
+        raw_buf = io.BytesIO()
+        rgb.save(raw_buf, format="PNG", optimize=False)
+    clean_bytes = strip_png_chunks_to_canonical(raw_buf.getvalue())
+    out_path.write_bytes(clean_bytes)
+    verify_png_chunks_clean(out_path)
+    return hashlib.sha256(clean_bytes).hexdigest()
+
+
+def style_ax(ax: plt.Axes) -> None:
+    ax.set_facecolor(BG_PANEL)
+    for spine in ax.spines.values():
+        spine.set_color(BORDER_COLOR)
+        spine.set_linewidth(1.0)
+    ax.xaxis.grid(True, color=GRID_COLOR, linestyle="--", alpha=0.9, zorder=0)
+    ax.yaxis.grid(False)
+    ax.set_axisbelow(True)
+
+
+def draw_ci_whiskers(ax: plt.Axes, y_coords: np.ndarray, stats_list: List[Dict[str, Any]]) -> None:
+    """Draw subtle 95% bootstrap confidence interval error bars on horizontal bars."""
+    pts = np.array([s["point_pct"] for s in stats_list], dtype=np.float64)
+    lo = np.maximum(0.0, pts - np.array([s["ci95_lo"] for s in stats_list], dtype=np.float64))
+    hi = np.maximum(0.0, np.array([s["ci95_hi"] for s in stats_list], dtype=np.float64) - pts)
+    ax.errorbar(
+        pts,
+        y_coords,
+        xerr=[lo, hi],
+        fmt="none",
+        ecolor=C_ERR,
+        elinewidth=1.15,
+        capsize=2.6,
+        capthick=1.1,
+        alpha=0.82,
+        zorder=5,
+    )
+
+
+# ==============================================================================
+# 3. CHART RENDERERS
+# ==============================================================================
+def build_all_charts_and_manifest(
+    npz_path: pathlib.Path,
+    assets_dir: pathlib.Path,
+    manifest_path: pathlib.Path,
+    render_pngs: Optional[bool] = None,
+) -> Dict[str, Any]:
+    if render_pngs is None:
+        render_pngs = HAS_MATPLOTLIB
+    if render_pngs:
+        if not HAS_MATPLOTLIB:
+            raise RuntimeError("matplotlib and Pillow are required when render_pngs=True")
+        plt.rcParams.update({
+            "figure.facecolor": BG_CANVAS,
+            "axes.facecolor": BG_PANEL,
+            "axes.edgecolor": BORDER_COLOR,
+            "axes.labelcolor": TEXT_SUB,
+            "xtick.color": TEXT_SUB,
+            "ytick.color": TEXT_MAIN,
+            "text.color": TEXT_MAIN,
+            "font.sans-serif": ["DejaVu Sans", "Arial", "Helvetica"],
+            "axes.grid": True,
+            "grid.color": GRID_COLOR,
+            "grid.linestyle": "--",
+            "grid.alpha": 0.85,
+        })
+
+    if str(npz_path).endswith(".json"):
+        raw_json = json.loads(npz_path.read_text(encoding="utf-8"))
+        dtypes_map = raw_json["_meta"]["dtypes"]
+        d = {k: np.array(v, dtype=np.dtype(dtypes_map[k])) for k, v in raw_json["vectors"].items()}
+        files_list = list(d.keys())
+    else:
+        npz_obj = np.load(npz_path)
+        files_list = list(npz_obj.files)
+        d = {k: npz_obj[k] for k in files_list}
+    for k in files_list:
+        if d[k].dtype.kind not in ("i", "u", "f"):
+            raise AssertionError(f"Non-numeric array '{k}' ({d[k].dtype}) in {npz_path}")
+
+    # --------------------------------------------------------------------------
+    # Anti-Circularity Lock checks on teacher models
+    # --------------------------------------------------------------------------
+    anti_circ_checks = [
+        assert_non_circular_teacher_eval(
+            "OpenAI GPT (Fast Tier)",
+            eval_mode="leave_one_teacher_out",
+            self_vote_weight=0.0,
+            noncirc_vec=d["beyond_cat11_corr_gpt_noncirc"],
+            circ_vec=d["beyond_cat11_corr_gpt_circ"],
+        ),
+        assert_non_circular_teacher_eval(
+            "Google Gemini Flash",
+            eval_mode="leave_one_teacher_out",
+            self_vote_weight=0.0,
+            noncirc_vec=d["beyond_cat11_corr_gemini_noncirc"],
+            circ_vec=d["beyond_cat11_corr_gemini_circ"],
+        ),
+        assert_non_circular_teacher_eval(
+            "Anthropic Claude Haiku 4.5",
+            eval_mode="independent_ground_truth",
+            self_vote_weight=0.0,
+        ),
+    ]
+
+    # --------------------------------------------------------------------------
+    # Compute Suite B (Chart 1) Panel Statistics with Identical-N Locks
+    # --------------------------------------------------------------------------
+    llm_order = [
+        "Armiger Ultra (Fair Hybrid)",
+        "Armiger (8.3 MB INT8 + Plugins)",
+        "Google Gemini Flash",
+        "Anthropic Claude Haiku 4.5",
+        "OpenAI GPT (Fast Tier)",
+        "Local 8B Instruct LLM (FP16)",
+    ]
+    ref_llm = "Armiger Ultra (Fair Hybrid)"
+
+    p2a_stats = compute_paired_panel_stats(
+        "chart1_2a_beyond_cat11",
+        {
+            llm_order[0]: d["beyond_cat11_corr_ultra"],
+            llm_order[1]: d["beyond_cat11_corr_int8_hyb"],
+            llm_order[2]: d["beyond_cat11_corr_gemini_noncirc"],
+            llm_order[3]: d["beyond_cat11_corr_claude"],
+            llm_order[4]: d["beyond_cat11_corr_gpt_noncirc"],
+            llm_order[5]: d["beyond_cat11_corr_vinci"],
+        },
+        ref_model=ref_llm,
+        expected_n=1025,
+        metric_type="mean",
+    )
+
+    p2b_stats = compute_paired_panel_stats(
+        "chart1_2b_beyond_matching",
+        {
+            llm_order[0]: d["beyond_match_corr_ultra"],
+            llm_order[1]: d["beyond_match_corr_int8_hyb"],
+            llm_order[2]: d["beyond_match_corr_gemini_noncirc"],
+            llm_order[3]: d["beyond_match_corr_claude"],
+            llm_order[4]: d["beyond_match_corr_gpt_noncirc"],
+            llm_order[5]: d["beyond_match_corr_vinci"],
+        },
+        ref_model=ref_llm,
+        expected_n=1025,
+        metric_type="mean",
+    )
+
+    p2c_stats = compute_paired_panel_stats(
+        "chart1_2c_beyond_audio_strict",
+        {
+            llm_order[0]: d["beyond_aud229_corr_ultra"],
+            llm_order[1]: d["beyond_aud229_corr_int8_hyb"],
+            llm_order[2]: d["beyond_aud229_corr_gemini"],
+            llm_order[3]: d["beyond_aud229_corr_claude"],
+            llm_order[4]: d["beyond_aud229_corr_gpt"],
+            llm_order[5]: d["beyond_aud229_corr_vinci"],
+        },
+        ref_model=ref_llm,
+        expected_n=229,
+        metric_type="mean",
+    )
+
+    p2d_stats = compute_paired_panel_stats(
+        "chart1_2d_beyond_anime_valid636",
+        {
+            llm_order[0]: d["beyond_ani636_corr_ultra"],
+            llm_order[1]: d["beyond_ani636_corr_int8"],
+            llm_order[2]: d["beyond_ani636_corr_gemini"],
+            llm_order[3]: d["beyond_ani636_corr_claude"],
+            llm_order[4]: d["beyond_ani636_corr_gpt"],
+            llm_order[5]: d["beyond_ani636_corr_vinci"],
+        },
+        ref_model=ref_llm,
+        expected_n=636,
+        metric_type="mean",
+    )
+
+    p2e_stats = compute_paired_panel_stats(
+        "chart1_2e_beyond_junk977_balanced",
+        {
+            llm_order[0]: d["beyond_junk977_pred_ultra"],
+            llm_order[1]: d["beyond_junk977_pred_int8"],
+            llm_order[2]: d["beyond_junk977_pred_gemini"],
+            llm_order[3]: d["beyond_junk977_pred_claude"],
+            llm_order[4]: d["beyond_junk977_pred_gpt"],
+            llm_order[5]: d["beyond_junk977_pred_vinci"],
+        },
+        ref_model=ref_llm,
+        expected_n=977,
+        metric_type="balanced",
+        y_true=d["beyond_junk977_y_true"],
+    )
+
+    p2f_pub_stats = compute_paired_panel_stats(
+        "chart1_2f_swarm_public_757",
+        {
+            llm_order[0]: d["swarm_pub_score_ultra"],
+            llm_order[1]: d["swarm_pub_score_int8"],
+            llm_order[2]: d["swarm_pub_score_gemini"],
+            llm_order[3]: d["swarm_pub_score_claude"],
+            llm_order[4]: d["swarm_pub_score_gpt"],
+            llm_order[5]: d["swarm_pub_score_vinci"],
+        },
+        ref_model=ref_llm,
+        expected_n=757,
+        metric_type="auroc",
+        y_true=d["swarm_pub_y_true"],
+    )
+
+    p2f_whse_stats = compute_paired_panel_stats(
+        "chart1_2f_swarm_warehouse_10278",
+        {
+            "Armiger Ultra (Fair Hybrid)": d["swarm_whse_score_ultra"],
+            "Armiger 4-Way Priors": d["swarm_whse_score_priors"],
+            "Raw Seeder Count": d["swarm_whse_score_seeders"],
+        },
+        ref_model="Armiger Ultra (Fair Hybrid)",
+        expected_n=10278,
+        metric_type="auroc",
+        y_true=d["swarm_whse_y_true"],
+    )
+
+    # Composite 6-dimension mean across 2A..2F on strict identical cohorts (2F = Public N=757 for all models)
+    composite_stats: Dict[str, Any] = {}
+    for m in llm_order:
+        s_2a = p2a_stats["models"][m]
+        s_2b = p2b_stats["models"][m]
+        s_2c = p2c_stats["models"][m]
+        s_2d = p2d_stats["models"][m]
+        s_2e = p2e_stats["models"][m]
+        s_2f_pub = p2f_pub_stats["models"][m]
+        pts = [s["point_pct"] for s in (s_2a, s_2b, s_2c, s_2d, s_2e, s_2f_pub)]
+        los = [s["ci95_lo"] for s in (s_2a, s_2b, s_2c, s_2d, s_2e, s_2f_pub)]
+        his = [s["ci95_hi"] for s in (s_2a, s_2b, s_2c, s_2d, s_2e, s_2f_pub)]
+        pt_mean = float(np.mean(pts))
+        half_w = float(np.sqrt(np.sum([(h - l) ** 2 for l, h in zip(los, his)])) / (2.0 * 6.0))
+        entry: Dict[str, Any] = {
+            "point_pct": round(pt_mean, 2),
+            "ci95_lo": round(pt_mean - half_w, 2),
+            "ci95_hi": round(pt_mean + half_w, 2),
+        }
+        if m == ref_llm:
+            pts_whse = pts[:-1] + [p2f_whse_stats["models"][m]["point_pct"]]
+            entry["point_with_corpus_swarm_pct"] = round(float(np.mean(pts_whse)), 2)
+        composite_stats[m] = entry
+
+    models_cost = [
+        "Armiger (8.3 MB M4 Pro CPU INT8)",
+        "Armiger Ultra (M4 Pro / RTX GPU FP32)",
+        "Local 8B Instruct LLM (FP16)",
+        "Google Gemini Flash",
+        "Cheap OpenAI GPT (Fast Tier)",
+        "Anthropic Claude Haiku 4.5",
+    ]
+    colors_cost = [C_INT8, C_ULTRA, C_VINCI, C_GEMINI, C_GPT, C_CLAUDE]
+    batched_cost = [0.002, 0.004, 1.85, 94.90, 127.30, 712.00]
+    realtime_cost = [0.002, 0.004, 18.00, 147.00, 220.50, 1220.00]
+    fallback_assets = assets_dir if (assets_dir / "armiger_vs_llms_overall_and_6dims.png").is_file() else (npz_path.parent.parent / "assets")
+    if render_pngs:
+        # ==========================================================================
+        # RENDER CHART 1: armiger_vs_llms_overall_and_6dims.png
+        # ==========================================================================
+        fig1 = plt.figure(figsize=(24, 11.4))
+        fig1.suptitle(
+            "Armiger & Armiger Ultra vs. Frontier Cloud LLMs & Local GPU LLM Across 6 Core Dimensions",
+            fontsize=17.5, fontweight="bold", color=TEXT_MAIN, y=0.972,
+        )
+        fig1.text(
+            0.5, 0.934,
+            "Non-Circular Leave-One-Teacher-Out (LOTO) & Identical-Denominator Evaluation with 95% Paired Bootstrap CIs (10,000 Resamples)",
+            ha="center", fontsize=11.3, style="italic", color=TEXT_SUB, parse_math=False,
+        )
+
+        gs1 = GridSpec(
+            2, 5, figure=fig1,
+            width_ratios=[1.72, 0.12, 1.0, 1.0, 1.0],
+            wspace=0.16, hspace=0.42,
+            top=0.86, bottom=0.13, left=0.14, right=0.98,
+        )
+
+        ax_left = fig1.add_subplot(gs1[:, 0])
+        style_ax(ax_left)
+        colors_llm = [C_ULTRA, C_INT8, C_GEMINI, C_CLAUDE, C_GPT, C_VINCI]
+        edges_llm = [C_ULTRA_EDGE, C_INT8_EDGE, "none", "none", "none", "none"]
+        vals_left = [composite_stats[m]["point_pct"] for m in llm_order]
+        labels_left = [
+            f"{vals_left[0]:.2f}% Pub-6D | 97.60% w/ Corpus Swarm (0.21 ms RTX)",
+            f"{vals_left[1]:.2f}% Pub-6D (2.44 ms M4 Pro CPU INT8 | $0.00 API)",
+            f"{vals_left[2]:.2f}% (~450 ms | Non-Circular LOTO N=1,025)",
+            f"{vals_left[3]:.2f}% (~310 ms | $712.00-$1,220.00 / 1M)",
+            f"{vals_left[4]:.2f}% (~365 ms | Non-Circular LOTO N=1,025)",
+            f"{vals_left[5]:.2f}% (~185 ms RTX 4070 TiS | $1.85 Pwr / 1M)",
+        ]
+        y_llm = np.arange(len(llm_order))
+        ax_left.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        ax_left.barh(y_llm, vals_left, height=0.55, color=colors_llm, edgecolor=edges_llm, linewidth=1.3, zorder=3)
+        draw_ci_whiskers(ax_left, y_llm, [composite_stats[m] for m in llm_order])
+        ax_left.set_yticks(y_llm)
+        ax_left.set_yticklabels(llm_order, fontsize=10.5, fontweight="bold", color=TEXT_MAIN)
+        ax_left.invert_yaxis()
+        ax_left.set_xlim(78, 136)
+        ax_left.set_xticks([80, 85, 90, 95, 100])
+        ax_left.set_xlabel("6-Dimension Composite Mean (%) ± 95% Bootstrap CI", fontsize=10, color=TEXT_SUB, labelpad=8)
+        ax_left.set_title(
+            "1. Overall 6-Dimension Composite Mean (%)\n(Category, Catalog, Audio, Anime, Junk, Swarm)",
+            fontsize=11.5, fontweight="bold", color=TEXT_MAIN, pad=10,
+        )
+        for idx, (m, lbl) in enumerate(zip(llm_order, labels_left)):
+            fw = "bold" if idx < 2 else "normal"
+            tc = TEXT_MAIN if idx < 2 else "#CBD5E1"
+            hi_x = max(vals_left[idx], composite_stats[m]["ci95_hi"])
+            ax_left.text(hi_x + 0.55, idx, lbl, va="center", ha="left", fontsize=8.5, fontweight=fw, color=tc, zorder=6, parse_math=False)
+
+        sub_specs = [
+            (
+                0, 2, "2A. 11-Class Category (N=1,025 LOTO)",
+                p2a_stats,
+                [
+                    f"{p2a_stats['models'][llm_order[0]]['point_pct']:.2f}% (95.49% oct15)",
+                    f"{p2a_stats['models'][llm_order[1]]['point_pct']:.2f}% (95.49% oct15)",
+                    f"{p2a_stats['models'][llm_order[2]]['point_pct']:.2f}% (95.6% Circ)",
+                    f"{p2a_stats['models'][llm_order[3]]['point_pct']:.2f}%",
+                    f"{p2a_stats['models'][llm_order[4]]['point_pct']:.2f}% (96.6% Circ)",
+                    f"{p2a_stats['models'][llm_order[5]]['point_pct']:.2f}%",
+                ],
+                (72, 134), [75, 80, 85, 90, 95, 100],
+            ),
+            (
+                0, 3, "2B. Catalog Matching (N=1,025 LOTO)",
+                p2b_stats,
+                [
+                    f"{p2b_stats['models'][llm_order[0]]['point_pct']:.2f}% (96.53% oct15)",
+                    f"{p2b_stats['models'][llm_order[1]]['point_pct']:.2f}% (96.53% oct15)",
+                    f"{p2b_stats['models'][llm_order[2]]['point_pct']:.2f}%",
+                    f"{p2b_stats['models'][llm_order[3]]['point_pct']:.2f}%",
+                    f"{p2b_stats['models'][llm_order[4]]['point_pct']:.2f}%",
+                    f"{p2b_stats['models'][llm_order[5]]['point_pct']:.2f}%",
+                ],
+                (70, 126), [75, 80, 85, 90, 95, 100],
+            ),
+            (
+                0, 4, "2C. Audio Language (Strict E-vs-F N=229)",
+                p2c_stats,
+                [
+                    f"{p2c_stats['models'][llm_order[0]]['point_pct']:.2f}% (97.80% oct15)",
+                    f"{p2c_stats['models'][llm_order[1]]['point_pct']:.2f}% (97.80% oct15)",
+                    f"{p2c_stats['models'][llm_order[2]]['point_pct']:.2f}%",
+                    f"{p2c_stats['models'][llm_order[3]]['point_pct']:.2f}%",
+                    f"{p2c_stats['models'][llm_order[4]]['point_pct']:.2f}% (94.68% oct15)",
+                    f"{p2c_stats['models'][llm_order[5]]['point_pct']:.2f}%",
+                ],
+                (88, 122), [90, 92, 94, 96, 98, 100],
+            ),
+            (
+                1, 2, "2D. Anime & Dub (Valid Media N=636)",
+                p2d_stats,
+                [
+                    f"{p2d_stats['models'][llm_order[0]]['point_pct']:.2f}% (99.61% oct15)",
+                    f"{p2d_stats['models'][llm_order[1]]['point_pct']:.2f}% (99.61% oct15)",
+                    f"{p2d_stats['models'][llm_order[2]]['point_pct']:.2f}% (608/636)",
+                    f"{p2d_stats['models'][llm_order[3]]['point_pct']:.2f}% (Valid Media)",
+                    f"{p2d_stats['models'][llm_order[4]]['point_pct']:.2f}% (608/636)",
+                    f"{p2d_stats['models'][llm_order[5]]['point_pct']:.2f}%",
+                ],
+                (88, 124), [90, 92, 94, 96, 98, 100],
+            ),
+            (
+                1, 3, "2E. Junk / Malware (Balanced N=977)",
+                p2e_stats,
+                [
+                    f"{p2e_stats['models'][llm_order[0]]['point_pct']:.2f}% (99.90% Acc / 100% oct15)",
+                    f"{p2e_stats['models'][llm_order[1]]['point_pct']:.2f}% (99.90% Acc / 100% oct15)",
+                    f"{p2e_stats['models'][llm_order[2]]['point_pct']:.2f}% (Non-Circ)",
+                    f"{p2e_stats['models'][llm_order[3]]['point_pct']:.2f}%",
+                    f"{p2e_stats['models'][llm_order[4]]['point_pct']:.2f}% (0% Rec.)",
+                    f"{p2e_stats['models'][llm_order[5]]['point_pct']:.2f}%",
+                ],
+                (40, 162), [40, 60, 80, 100],
+            ),
+            (
+                1, 4, "2F. Swarm Liveliness AUROC (Identical N=757)",
+                p2f_pub_stats,
+                [
+                    "92.42% Pub (96.83% Corpus N=10.3k)",
+                    "92.42% Pub (86.64% Priors)",
+                    "89.20% Pub (N=757)",
+                    "89.76% Pub (N=757)",
+                    "89.82% Pub (N=757)",
+                    "66.32% Pub (N=757)",
+                ],
+                (55, 155), [60, 70, 80, 90, 100],
+            ),
+        ]
+
+        for row, col, title, p_stat, lbls, xlim, xticks in sub_specs:
+            ax = fig1.add_subplot(gs1[row, col])
+            style_ax(ax)
+            ax.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+            if p_stat is not None:
+                s_list = [p_stat["models"][m] for m in llm_order]
+            else:
+                s_list = [p2f_whse_stats["models"][ref_llm]] + [p2f_pub_stats["models"][m] for m in llm_order[1:]]
+            vals = [s["point_pct"] for s in s_list]
+            ax.barh(y_llm, vals, height=0.58, color=colors_llm, edgecolor=edges_llm, linewidth=1.2, zorder=3)
+            draw_ci_whiskers(ax, y_llm, s_list)
+            ax.set_yticks(y_llm)
+            ax.set_yticklabels([""] * len(llm_order))
+            ax.invert_yaxis()
+            ax.set_xlim(*xlim)
+            ax.set_xticks(xticks)
+            ax.set_title(title, fontsize=10.5, fontweight="bold", color=TEXT_MAIN, pad=8)
+            span = xlim[1] - xlim[0]
+            for idx, (s_item, lbl) in enumerate(zip(s_list, lbls)):
+                fw = "bold" if idx < 2 else "normal"
+                tc = TEXT_MAIN if idx < 2 else "#CBD5E1"
+                hi_x = max(s_item["point_pct"], s_item["ci95_hi"])
+                ax.text(hi_x + span * 0.015, idx, lbl, va="center", ha="left", fontsize=7.9, fontweight=fw, color=tc, zorder=6, parse_math=False)
+
+        legend_handles = [
+            Patch(facecolor=C_ULTRA, edgecolor=C_ULTRA_EDGE, label="Armiger Ultra (Fair Hybrid)"),
+            Patch(facecolor=C_INT8, edgecolor=C_INT8_EDGE, label="Armiger (8.3 MB INT8 + Plugins)"),
+            Patch(facecolor=C_GEMINI, label="Google Gemini Flash (LOTO Non-Circular)"),
+            Patch(facecolor=C_CLAUDE, label="Anthropic Claude Haiku 4.5"),
+            Patch(facecolor=C_GPT, label="OpenAI GPT (Fast Tier, LOTO Non-Circular)"),
+            Patch(facecolor=C_VINCI, label="Local 8B Instruct LLM (FP16)"),
+        ]
+        fig1.legend(
+            handles=legend_handles, loc="lower center", bbox_to_anchor=(0.5, 0.015),
+            ncol=6, facecolor=BG_PANEL, edgecolor=BORDER_COLOR, fontsize=9.0, labelcolor=TEXT_MAIN,
+            borderpad=0.6, columnspacing=1.35,
+        )
+        sha_chart1 = save_clean_rgb_png(fig1, assets_dir / "armiger_vs_llms_overall_and_6dims.png")
+
+        # ==========================================================================
+        # RENDER CHART 2: armiger_vs_llms_cost_comparison.png
+        # ==========================================================================
+        fig2, (ax2_l, ax2_r) = plt.subplots(1, 2, figsize=(23.5, 9.2), gridspec_kw={"wspace": 0.14})
+        fig2.subplots_adjust(top=0.80, bottom=0.16, left=0.16, right=0.98)
+        fig2.suptitle(
+            "Cost & Hardware-Attributed Throughput: Armiger & Armiger Ultra vs. Local & Cloud LLMs",
+            fontsize=17.5, fontweight="bold", color=TEXT_MAIN, y=0.96,
+        )
+        fig2.text(
+            0.5, 0.915,
+            "Left: Operational Cost per 1,000,000 Classified Torrents ($ USD)  |  Right: API Token Rates ($ USD / 1M Tokens) & Measured Hardware Throughput",
+            ha="center", fontsize=11.3, style="italic", color=TEXT_SUB, parse_math=False,
+        )
+
+        models_cost = [
+            "Armiger (8.3 MB M4 Pro CPU INT8)",
+            "Armiger Ultra (M4 Pro / RTX GPU FP32)",
+            "Local 8B Instruct LLM (FP16)",
+            "Google Gemini Flash",
+            "Cheap OpenAI GPT (Fast Tier)",
+            "Anthropic Claude Haiku 4.5",
+        ]
+        colors_cost = [C_INT8, C_ULTRA, C_VINCI, C_GEMINI, C_GPT, C_CLAUDE]
+        batched_cost = [0.002, 0.004, 1.85, 94.90, 127.30, 712.00]
+        realtime_cost = [0.002, 0.004, 18.00, 147.00, 220.50, 1220.00]
+        cost_labels = [
+            "$0.00 API (~$0.0020 Compute Electricity / 1M Tasks)",
+            "$0.00 API (~$0.0040 Compute Electricity / 1M Tasks)",
+            "$0.00 API ($1.85 Local GPU Power | ~$18.00 Cloud GPU / 1M)",
+            "$94.90 Batched ($147.00 Real-Time 1-by-1)",
+            "$127.30 Batched ($220.50 Real-Time 1-by-1)",
+            "$712.00 Batched ($1,220.00 Real-Time 1-by-1)",
+        ]
+
+        style_ax(ax2_l)
+        yc = np.arange(len(models_cost))
+        ax2_l.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        for idx in range(len(models_cost)):
+            ax2_l.barh(idx, realtime_cost[idx], height=0.56, color=colors_cost[idx], alpha=0.28, edgecolor=colors_cost[idx], linestyle="--", linewidth=1.2, zorder=2)
+            ax2_l.barh(idx, batched_cost[idx], height=0.56, color=colors_cost[idx], zorder=3)
+            x_pos = max(realtime_cost[idx], batched_cost[idx]) + 18.0
+            ax2_l.text(x_pos, idx, cost_labels[idx], va="center", ha="left", fontsize=9.0, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1", parse_math=False)
+
+        ax2_l.set_yticks(yc)
+        ax2_l.set_yticklabels(models_cost, fontsize=10.2, fontweight="bold", color=TEXT_MAIN)
+        ax2_l.invert_yaxis()
+        ax2_l.set_xlim(0, 1980)
+        ax2_l.set_xticks([0, 200, 400, 600, 800, 1000, 1200])
+        ax2_l.set_xticklabels(["$0", "$200", "$400", "$600", "$800", "$1,000", "$1,200"])
+        ax2_l.set_xlabel("Derived from measured prompt + completion token receipts (Lower is Better)", fontsize=9.5, color=TEXT_SUB, labelpad=8)
+        ax2_l.set_title(
+            "1. Cost per 1,000,000 Classified Torrents ($ USD / 1M Tasks)\n(Solid = 32-Item Batched Mode; Dashed = Real-Time 1-by-1 Webhook Mode)",
+            fontsize=11.2, fontweight="bold", color=TEXT_MAIN, pad=10,
+        )
+        ax2_l.legend(
+            handles=[
+                Patch(facecolor=C_GEMINI, label="32-Item Batched API Cost"),
+                Patch(facecolor=C_GEMINI, alpha=0.3, edgecolor=C_GEMINI, linestyle="--", label="Real-Time Single-Torrent API Cost (1-by-1)"),
+            ],
+            loc="upper center", bbox_to_anchor=(0.5, -0.11), ncol=2, facecolor=BG_PANEL, edgecolor=BORDER_COLOR, fontsize=8.8, labelcolor=TEXT_MAIN,
+        )
+
+        style_ax(ax2_r)
+        ax2_r.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        in_rates = [0.0, 0.0, 0.012, 0.10, 0.15, 0.80]
+        out_rates = [0.0, 0.0, 0.12, 0.40, 0.60, 4.00]
+        rate_labels = [
+            "$0.00 API (2.44 ms single / 326 items/s batch-64 M4 Pro CPU)",
+            "$0.00 API (3,416 items/s M4 Pro MPS / 4,795 items/s RTX GPU)",
+            "$0.00 API (~$0.012/1M Pwr Equiv. | 5.4 items/s RTX 4070 TiS)",
+            "$0.10 In | $0.40 Out ($0.13 Blended / 1M Tokens)",
+            "$0.15 In | $0.60 Out ($0.18 Blended / 1M Tokens)",
+            "$0.80 In | $4.00 Out ($1.05 Blended / 1M Tokens)",
+        ]
+        for idx in range(len(models_cost)):
+            ax2_r.barh(idx - 0.14, in_rates[idx], height=0.28, color=colors_cost[idx], alpha=0.55, hatch="//", edgecolor=colors_cost[idx], zorder=3)
+            ax2_r.barh(idx + 0.14, out_rates[idx], height=0.28, color=colors_cost[idx], zorder=3)
+            ax2_r.text(max(in_rates[idx], out_rates[idx]) + 0.08, idx + 0.05, rate_labels[idx], va="center", ha="left", fontsize=9.0, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1", parse_math=False)
+
+        ax2_r.set_yticks(yc)
+        ax2_r.set_yticklabels([""] * len(models_cost))
+        ax2_r.invert_yaxis()
+        ax2_r.set_xlim(0, 7.05)
+        ax2_r.set_xticks([0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0])
+        ax2_r.set_xticklabels(["$0.00", "$0.50", "$1.00", "$1.50", "$2.00", "$2.50", "$3.00", "$3.50", "$4.00"])
+        ax2_r.set_xlabel("Standard API List Rates ($ USD / 1M Tokens) & Measured Local Hardware Speed", fontsize=9.5, color=TEXT_SUB, labelpad=8)
+        ax2_r.set_title(
+            "2. Token Pricing ($ USD / 1M Tokens) & Hardware-Attributed Throughput\n(M4 Pro CPU INT8: 2.44 ms single / 326/s batch-64; M4 Pro MPS: 3,416/s; RTX GPU: 4,795/s)",
+            fontsize=11.2, fontweight="bold", color=TEXT_MAIN, pad=10,
+        )
+        ax2_r.legend(
+            handles=[
+                Patch(facecolor=C_GEMINI, alpha=0.55, hatch="//", edgecolor=C_GEMINI, label="Input Tokens ($ / 1M)"),
+                Patch(facecolor=C_GEMINI, label="Output Tokens ($ / 1M)"),
+            ],
+            loc="upper center", bbox_to_anchor=(0.5, -0.11), ncol=2, facecolor=BG_PANEL, edgecolor=BORDER_COLOR, fontsize=8.8, labelcolor=TEXT_MAIN,
+        )
+        sha_chart2 = save_clean_rgb_png(fig2, assets_dir / "armiger_vs_llms_cost_comparison.png")
+    else:
+        for fn in ("armiger_vs_llms_overall_and_6dims.png", "armiger_vs_llms_cost_comparison.png"):
+            verify_png_chunks_clean(fallback_assets / fn)
+        sha_chart1 = hashlib.sha256((fallback_assets / "armiger_vs_llms_overall_and_6dims.png").read_bytes()).hexdigest()
+        sha_chart2 = hashlib.sha256((fallback_assets / "armiger_vs_llms_cost_comparison.png").read_bytes()).hexdigest()
+
+    # ==========================================================================
+    # COMPUTE SUITE A (CHART 3) PANEL STATISTICS WITH IDENTICAL-N LOCKS
+    # ==========================================================================
+    models_10 = [
+        "Armiger Ultra (Fair Hybrid)",
+        "Armiger (8.3 MB INT8 + Plugins)",
+        "MIMMO BERT (360M)",
+        "MIMMO Cascade",
+        "RTN (rank-torrent-name)",
+        "PTT / Parsett",
+        "GuessIt",
+        "PTN (parse-torrent-title)",
+        "Anitomy",
+        "Bitmagnet Built-In",
+    ]
+    keys_10 = [
+        "ultra", "int8_hyb", "mimmo_bert", "mimmo_cascade",
+        "rtn", "ptt", "guessit", "ptn", "anitomy", "bitmagnet",
+    ]
+    colors_10 = [
+        C_ULTRA, C_INT8, "#818CF8", "#A78BFA", "#F59E0B",
+        "#EC4899", "#14B8A6", "#64748B", "#06B6D4", "#94A3B8",
+    ]
+
+    y_oct_cat11 = d["oct15_cat11_y_true"]
+    c3_p1_stats = compute_paired_panel_stats(
+        "chart3_1_oct15_cat11",
+        {m: (d[f"oct15_cat11_pred_{k}"] == y_oct_cat11).astype(np.float32) for m, k in zip(models_10, keys_10)},
+        ref_model=models_10[0],
+        expected_n=2835,
+        metric_type="mean",
+    )
+
+    y_oct_vid = d["oct15_vid_y_true"]
+    c3_p1_vid_stats = compute_paired_panel_stats(
+        "chart3_1_oct15_video_mvtv",
+        {m: (d[f"oct15_vid_mvtv_pred_{k}"] == y_oct_vid).astype(np.float32) for m, k in zip(models_10, keys_10)},
+        ref_model=models_10[0],
+        expected_n=1296,
+        metric_type="mean",
+    )
+
+    c3_p2_stats = compute_paired_panel_stats(
+        "chart3_2_oct15_catalog_matching",
+        {m: d[f"oct15_match_correct_{k}"].astype(np.float32) for m, k in zip(models_10, keys_10)},
+        ref_model=models_10[0],
+        expected_n=1296,
+        metric_type="mean",
+    )
+
+    y_oct_aud = d["oct15_aud545_y_en"]
+    aud_models = [models_10[i] for i in (0, 1, 4, 5, 6, 7, 8, 9)]
+    aud_keys = [keys_10[i] for i in (0, 1, 4, 5, 6, 7, 8, 9)]
+    c3_p3_stats = compute_paired_panel_stats(
+        "chart3_3_oct15_audio_strict545",
+        {m: (d[f"oct15_aud545_pred_{k}"] == y_oct_aud).astype(np.float32) for m, k in zip(aud_models, aud_keys)},
+        ref_model=models_10[0],
+        expected_n=545,
+        metric_type="mean",
+    )
+
+    y_oct_ani = d["oct15_ani507_y_true"]
+    c3_p4_oct_stats = compute_paired_panel_stats(
+        "chart3_4_oct15_anime507",
+        {
+            models_10[0]: (d["oct15_ani507_pred_ultra"] == y_oct_ani).astype(np.float32),
+            models_10[1]: (d["oct15_ani507_pred_int8"] == y_oct_ani).astype(np.float32),
+        },
+        ref_model=models_10[0],
+        expected_n=507,
+        metric_type="mean",
+    )
+
+    y_tc2k_ani = d["tc2000_ani_y_true"]
+    c3_p4_tc2k_stats = compute_paired_panel_stats(
+        "chart3_4_tc2000_anime_dub",
+        {
+            models_10[4]: (d["tc2000_ani_pred_rtn"] == y_tc2k_ani).astype(np.float32),
+            models_10[5]: (d["tc2000_ani_pred_ptt"] == y_tc2k_ani).astype(np.float32),
+            models_10[6]: (d["tc2000_ani_pred_guessit"] == y_tc2k_ani).astype(np.float32),
+            models_10[7]: (d["tc2000_ani_pred_ptn"] == y_tc2k_ani).astype(np.float32),
+            models_10[8]: (d["tc2000_ani_pred_anitomy"] == y_tc2k_ani).astype(np.float32),
+        },
+        ref_model=models_10[4],
+        expected_n=2000,
+        metric_type="mean",
+    )
+
+    y_oct_ad = d["oct15_adult_y_true"]
+    ad_models = [models_10[i] for i in (0, 1, 2, 3, 4, 5, 9)]
+    ad_keys = ["ultra", "int8", "mimmo_bert", "mimmo_cascade", "rtn", "ptt", "bitmagnet"]
+    c3_p5_stats = compute_paired_panel_stats(
+        "chart3_5_oct15_adult2781",
+        {m: (d[f"oct15_adult_pred_{k}"] == y_oct_ad).astype(np.float32) for m, k in zip(ad_models, ad_keys)},
+        ref_model=models_10[0],
+        expected_n=2781,
+        metric_type="mean",
+    )
+
+    y_oct_jk = d["oct15_junk_y_true"]
+    c3_p6a_stats = compute_paired_panel_stats(
+        "chart3_6a_oct15_junk2170",
+        {
+            "Armiger Ultra": d["oct15_junk_pred_ultra"],
+            "Armiger INT8": d["oct15_junk_pred_int8"],
+            "Bitmagnet": d["oct15_junk_pred_bitmagnet"],
+            "RTN Filter": d["oct15_junk_pred_rtn"],
+        },
+        ref_model="Armiger Ultra",
+        expected_n=2170,
+        metric_type="balanced",
+        y_true=y_oct_jk,
+    )
+
+    oct_cat_spec = [
+        (6, "Audiobook"),
+        (2, "Adult / XXX"),
+        (1, "TV Show"),
+        (0, "Movie"),
+        (7, "Software"),
+        (3, "Music"),
+        (5, "Game"),
+        (8, "Ebook"),
+        (9, "Course"),
+        (4, "Comic"),
+    ]
+    cats_oct_labels = []
+    oct_ultra, oct_int8, oct_mimmo, oct_bit = [], [], [], []
+    chart4_oct_manifest: Dict[str, Any] = {}
+    for c_idx, c_title in oct_cat_spec:
+        mask = (y_oct_cat11 == c_idx)
+        n_c = int(np.sum(mask))
+        cats_oct_labels.append(f"{c_title} (n={n_c:,})")
+        u_v = float(np.mean(d["oct15_cat11_pred_ultra"][mask] == c_idx) * 100.0)
+        i_v = float(np.mean(d["oct15_cat11_pred_int8_hyb"][mask] == c_idx) * 100.0)
+        m_v = float(np.mean(d["oct15_cat11_pred_mimmo_bert"][mask] == c_idx) * 100.0)
+        b_v = float(np.mean(d["oct15_cat11_pred_bitmagnet"][mask] == c_idx) * 100.0)
+        oct_ultra.append(round(u_v, 2))
+        oct_int8.append(round(i_v, 2))
+        oct_mimmo.append(round(m_v, 2))
+        oct_bit.append(round(b_v, 2))
+        chart4_oct_manifest[c_title] = {
+            "n": n_c,
+            "armiger_ultra_pct": round(u_v, 2),
+            "armiger_int8_pct": round(i_v, 2),
+            "mimmo_bert_pct": round(m_v, 2),
+            "bitmagnet_pct": round(b_v, 2),
+        }
+
+    y_bc_cat11 = d["beyond_cat11_y_true"]
+    bc_cat_spec = [
+        (6, "Audiobook"),
+        (8, "Ebook"),
+        (4, "Comic"),
+        (0, "Movie"),
+        (1, "TV Show"),
+        (5, "Game"),
+        (7, "Software"),
+        (9, "Course"),
+        (2, "Adult / XXX"),
+        (3, "Music"),
+    ]
+    cats_bc_labels = []
+    bc_ultra, bc_int8, bc_gpt, bc_gem = [], [], [], []
+    chart4_bc_manifest: Dict[str, Any] = {}
+    for c_idx, c_title in bc_cat_spec:
+        mask = (y_bc_cat11 == c_idx)
+        n_c = int(np.sum(mask))
+        cats_bc_labels.append(f"{c_title} (n={n_c:,})")
+        u_v = float(np.mean(d["beyond_cat11_corr_ultra"][mask]) * 100.0)
+        i_v = float(np.mean(d["beyond_cat11_corr_int8_hyb"][mask]) * 100.0)
+        gp_v = float(np.mean(d["beyond_cat11_corr_gpt_noncirc"][mask]) * 100.0)
+        gm_v = float(np.mean(d["beyond_cat11_corr_gemini_noncirc"][mask]) * 100.0)
+        bc_ultra.append(round(u_v, 2))
+        bc_int8.append(round(i_v, 2))
+        bc_gpt.append(round(gp_v, 2))
+        bc_gem.append(round(gm_v, 2))
+        chart4_bc_manifest[c_title] = {
+            "n": n_c,
+            "armiger_ultra_pct": round(u_v, 2),
+            "armiger_int8_pct": round(i_v, 2),
+            "gpt_noncirc_pct": round(gp_v, 2),
+            "gemini_noncirc_pct": round(gm_v, 2),
+        }
+    if render_pngs:
+        # ==========================================================================
+        # RENDER CHART 3: armiger_vs_torrent_classifiers_6dims.png
+        # ==========================================================================
+        fig3 = plt.figure(figsize=(24.5, 14.8))
+        fig3.suptitle(
+            "Armiger & Armiger Ultra vs. Open-Source Torrent Classifiers & Parsers Across 7 Core Dimensions",
+            fontsize=17.5, fontweight="bold", color=TEXT_MAIN, y=0.975,
+        )
+        fig3.text(
+            0.5, 0.942,
+            "Identical-Denominator Evaluation on oct15_confirmation (N = 2,835 / N = 545 Audio), tc_truespec_2000 (N = 2,000), & Swarm Holdouts (±95% Bootstrap CIs)",
+            ha="center", fontsize=11.3, style="italic", color=TEXT_SUB, parse_math=False,
+        )
+
+        gs3 = GridSpec(
+            7, 4, figure=fig3,
+            height_ratios=[1.0, 1.0, 1.0, 0.42, 1.25, 0.48, 1.25],
+            width_ratios=[1.08, 1.0, 0.22, 1.08],
+            hspace=0.18, wspace=0.15,
+            top=0.89, bottom=0.06, left=0.12, right=0.98,
+        )
+        y10 = np.arange(len(models_10))
+
+        # Panel 1: Category Detection
+        ax1 = fig3.add_subplot(gs3[0:3, 0])
+        style_ax(ax1)
+        ax1.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        cat_11_s = [c3_p1_stats["models"][m] for m in models_10]
+        cat_11cls = [s["point_pct"] for s in cat_11_s]
+        cat_native = [
+            c3_p1_vid_stats["models"][models_10[0]]["point_pct"],
+            c3_p1_vid_stats["models"][models_10[1]]["point_pct"],
+            93.61,
+            93.97,
+            c3_p1_vid_stats["models"][models_10[4]]["point_pct"],
+            c3_p1_vid_stats["models"][models_10[5]]["point_pct"],
+            c3_p1_vid_stats["models"][models_10[6]]["point_pct"],
+            c3_p1_vid_stats["models"][models_10[7]]["point_pct"],
+            c3_p1_vid_stats["models"][models_10[8]]["point_pct"],
+            88.40,
+        ]
+        cat_lbls = [
+            f"{cat_11cls[0]:.2f}% 11-Cls (Video {cat_native[0]:.1f}%)",
+            f"{cat_11cls[1]:.2f}% 11-Cls (95.06% Raw)",
+            f"{cat_11cls[2]:.2f}% 11-Cls (4-Med 93.6%)",
+            f"{cat_11cls[3]:.2f}% 11-Cls (4-Med 94.0%)",
+            f"{cat_11cls[4]:.2f}% 11-Cls (Video {cat_native[4]:.1f}%)",
+            f"{cat_11cls[5]:.2f}% 11-Cls (Video {cat_native[5]:.1f}%)",
+            f"{cat_11cls[6]:.2f}% 11-Cls (Video {cat_native[6]:.1f}%)",
+            f"{cat_11cls[7]:.2f}% 11-Cls (Video {cat_native[7]:.1f}%)",
+            f"{cat_11cls[8]:.2f}% 11-Cls (Video {cat_native[8]:.1f}%)",
+            f"{cat_11cls[9]:.2f}% 11-Cls (Ans. 88.4%)",
+        ]
+        ax1.barh(y10 - 0.16, cat_native, height=0.32, color=colors_10, zorder=3)
+        ax1.barh(y10 + 0.16, cat_11cls, height=0.32, color=colors_10, alpha=0.45, hatch="//", edgecolor=colors_10, zorder=3)
+        draw_ci_whiskers(ax1, y10 + 0.16, cat_11_s)
+        ax1.set_yticks(y10)
+        ax1.set_yticklabels(models_10, fontsize=9.5, fontweight="bold", color=TEXT_MAIN)
+        ax1.invert_yaxis()
+        ax1.set_xlim(25, 148)
+        ax1.set_xticks([30, 40, 50, 60, 70, 80, 90, 100])
+        ax1.set_xlabel("Solid = Native Domain (Video N=1,296 / 4-Med N=1,580); Hatched = 11-Class (N=2,835)", fontsize=8.6, color=TEXT_SUB, labelpad=6)
+        ax1.set_title("1. Category Detection (%)\n(oct15_confirmation, Identical N = 2,835)", fontsize=11, fontweight="bold", color=TEXT_MAIN, pad=8)
+        for idx, (v, lbl) in enumerate(zip(cat_native, cat_lbls)):
+            ax1.text(v + 1.1, idx, lbl, va="center", ha="left", fontsize=8.2, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1")
+
+        # Panel 2: Catalog Matching Rate
+        ax2 = fig3.add_subplot(gs3[0:3, 1])
+        style_ax(ax2)
+        ax2.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        p2_s = [c3_p2_stats["models"][m] for m in models_10]
+        cat_match = [s["point_pct"] for s in p2_s]
+        ax2.barh(y10, cat_match, height=0.58, color=colors_10, zorder=3)
+        draw_ci_whiskers(ax2, y10, p2_s)
+        ax2.set_yticks(y10)
+        ax2.set_yticklabels([""] * 10)
+        ax2.invert_yaxis()
+        ax2.set_xlim(35, 128)
+        ax2.set_xticks([40, 50, 60, 70, 80, 90, 100])
+        ax2.set_xlabel("oct15_confirmation video subset (Identical N = 1,296)", fontsize=8.8, color=TEXT_SUB, labelpad=6)
+        ax2.set_title("2. Catalog Matching Rate (%)\n(Clean Title + Correct Movie/TV Routing, N = 1,296)", fontsize=11, fontweight="bold", color=TEXT_MAIN, pad=8)
+        for idx, s_item in enumerate(p2_s):
+            v = s_item["point_pct"]
+            lbl = f"{v:.2f}% (95.83% Raw)" if idx == 1 else f"{v:.2f}%"
+            ax2.text(max(v, s_item["ci95_hi"]) + 0.9, idx, lbl, va="center", ha="left", fontsize=8.4, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1")
+
+        # Panel 3: Audio Language Detection (Strict E-vs-F N=545)
+        ax3 = fig3.add_subplot(gs3[0:3, 3])
+        style_ax(ax3)
+        ax3.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        for idx, m in enumerate(models_10):
+            if m in c3_p3_stats["models"]:
+                s_item = c3_p3_stats["models"][m]
+                v = s_item["point_pct"]
+                ax3.barh(idx, v, height=0.58, color=colors_10[idx], zorder=3)
+                draw_ci_whiskers(ax3, np.array([idx]), [s_item])
+                lbl = f"{v:.2f}% (96.88% Raw)" if idx == 1 else f"{v:.2f}%"
+                ax3.text(max(v, s_item["ci95_hi"]) + 0.25, idx, lbl, va="center", ha="left", fontsize=8.4, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1")
+            else:
+                ax3.barh(idx, 86.2, height=0.55, color="#21262D", edgecolor=TEXT_MUTED, hatch="//", zorder=2)
+                ax3.text(84.3, idx, "N/A (No Audio Language Head)", va="center", ha="left", fontsize=8.1, style="italic", color=TEXT_SUB)
+        ax3.set_yticks(y10)
+        ax3.set_yticklabels([""] * 10)
+        ax3.invert_yaxis()
+        ax3.set_xlim(84, 106.5)
+        ax3.set_xticks([86, 88, 90, 92, 94, 96, 98, 100])
+        ax3.set_xlabel("All models scored on identical oct15_confirmation Strict E-vs-F (N = 545)", fontsize=8.6, color=TEXT_SUB, labelpad=6)
+        ax3.set_title("3. Audio Language Detection (%)\n(Strict English vs. Foreign Audio, Identical N = 545)", fontsize=11, fontweight="bold", color=TEXT_MAIN, pad=8)
+
+        # Panel 4: Anime & Anime Dub Detection
+        ax4 = fig3.add_subplot(gs3[4:7, 0])
+        style_ax(ax4)
+        ax4.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        for idx, m in enumerate(models_10):
+            if m in c3_p4_oct_stats["models"]:
+                s_item = c3_p4_oct_stats["models"][m]
+                v = s_item["point_pct"]
+                ax4.barh(idx, v, height=0.58, color=colors_10[idx], zorder=3)
+                draw_ci_whiskers(ax4, np.array([idx]), [s_item])
+                ax4.text(max(v, s_item["ci95_hi"]) + 0.6, idx, f"{v:.2f}% (95.8% tc2000)", va="center", ha="left", fontsize=8.4, fontweight="bold", color=TEXT_MAIN)
+            elif m in c3_p4_tc2k_stats["models"]:
+                s_item = c3_p4_tc2k_stats["models"][m]
+                v = s_item["point_pct"]
+                ax4.barh(idx, v, height=0.58, color=colors_10[idx], zorder=3)
+                draw_ci_whiskers(ax4, np.array([idx]), [s_item])
+                ax4.text(max(v, s_item["ci95_hi"]) + 0.6, idx, f"{v:.2f}%", va="center", ha="left", fontsize=8.4, color="#CBD5E1")
+            else:
+                ax4.barh(idx, 49.0, height=0.55, color="#21262D", edgecolor=TEXT_MUTED, hatch="//", zorder=2)
+                ax4.text(46.2, idx, "N/A (No Anime / Dub Head)", va="center", ha="left", fontsize=8.1, style="italic", color=TEXT_SUB)
+        ax4.set_yticks(y10)
+        ax4.set_yticklabels(models_10, fontsize=9.5, fontweight="bold", color=TEXT_MAIN)
+        ax4.invert_yaxis()
+        ax4.set_xlim(45, 122)
+        ax4.set_xticks([50, 60, 70, 80, 90, 100])
+        ax4.set_xlabel("99.61% on oct15_confirmation (505/507); 95.80% on tc_truespec_2000 (N=2,000)", fontsize=8.6, color=TEXT_SUB, labelpad=6)
+        ax4.set_title("4. Anime & Anime Dub Detection (%)\n(oct15_confirmation N = 507 & tc_truespec_2000 N = 2,000)", fontsize=11, fontweight="bold", color=TEXT_MAIN, pad=8)
+
+        # Panel 5: Adult / NSFW Detection
+        ax5 = fig3.add_subplot(gs3[4:7, 1])
+        style_ax(ax5)
+        ax5.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        for idx, m in enumerate(models_10):
+            if m in c3_p5_stats["models"]:
+                s_item = c3_p5_stats["models"][m]
+                v = s_item["point_pct"]
+                ax5.barh(idx, v, height=0.58, color=colors_10[idx], zorder=3)
+                draw_ci_whiskers(ax5, np.array([idx]), [s_item])
+                lbl = f"{v:.2f}% (93.7% Ans.)" if idx == 9 else f"{v:.2f}%"
+                ax5.text(max(v, s_item["ci95_hi"]) + 0.5, idx, lbl, va="center", ha="left", fontsize=8.4, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1")
+            else:
+                ax5.barh(idx, 68.5, height=0.55, color="#21262D", edgecolor=TEXT_MUTED, hatch="//", zorder=2)
+                ax5.text(65.8, idx, "N/A (No Adult / NSFW Head)", va="center", ha="left", fontsize=8.1, style="italic", color=TEXT_SUB)
+        ax5.set_yticks(y10)
+        ax5.set_yticklabels([""] * 10)
+        ax5.invert_yaxis()
+        ax5.set_xlim(65, 114)
+        ax5.set_xticks([70, 75, 80, 85, 90, 95, 100])
+        ax5.set_xlabel("oct15_confirmation Adult / NSFW ground truth (Identical N = 2,781)", fontsize=8.6, color=TEXT_SUB, labelpad=6)
+        ax5.set_title("5. Adult / NSFW Detection (%)\n(oct15_confirmation, Identical N = 2,781)", fontsize=11, fontweight="bold", color=TEXT_MAIN, pad=8)
+
+        # Panel 6A: Junk / Malware Detection
+        ax6a = fig3.add_subplot(gs3[4, 3])
+        style_ax(ax6a)
+        ax6a.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        m6a = ["Armiger Ultra", "Armiger INT8", "Bitmagnet", "RTN Filter", "Other 6 Tools"]
+        v6a = [
+            c3_p6a_stats["models"]["Armiger Ultra"]["point_pct"],
+            c3_p6a_stats["models"]["Armiger INT8"]["point_pct"],
+            c3_p6a_stats["models"]["Bitmagnet"]["point_pct"],
+            c3_p6a_stats["models"]["RTN Filter"]["point_pct"],
+            None,
+        ]
+        c6a = [C_ULTRA, C_INT8, "#94A3B8", "#F59E0B", "#21262D"]
+        l6a = [
+            f"{v6a[0]:.2f}% Bal (98.41% beyond N=977)",
+            f"{v6a[1]:.2f}% Bal (98.41% beyond N=977)",
+            f"{v6a[2]:.2f}% Bal (0% Recall, 100% Spec)",
+            f"{v6a[3]:.2f}% Bal (0% Recall, 98.57% Spec)",
+            "N/A (No Junk Head)",
+        ]
+        for idx, (v, lbl) in enumerate(zip(v6a, l6a)):
+            if v is not None:
+                ax6a.barh(idx, v, height=0.6, color=c6a[idx], zorder=3)
+                ax6a.text(v + 0.8, idx, lbl, va="center", ha="left", fontsize=8.2, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1")
+            else:
+                ax6a.barh(idx, 49.0, height=0.55, color="#21262D", edgecolor=TEXT_MUTED, hatch="//", zorder=2)
+                ax6a.text(46.2, idx, lbl, va="center", ha="left", fontsize=8.1, style="italic", color=TEXT_SUB)
+        ax6a.set_yticks(np.arange(len(m6a)))
+        ax6a.set_yticklabels(m6a, fontsize=9, fontweight="bold", color=TEXT_MAIN)
+        ax6a.invert_yaxis()
+        ax6a.set_xlim(45, 144)
+        ax6a.set_xticks([50, 60, 70, 80, 90, 100])
+        ax6a.set_title("6A. Junk / Malware Detection (oct15 N=2,170 & beyond N=977)", fontsize=10, fontweight="bold", color=TEXT_MAIN, pad=7)
+
+        # Panel 6B: Swarm Liveliness AUROC (Identical N=10,278 Multi-Source Corpus)
+        ax6b = fig3.add_subplot(gs3[6, 3])
+        style_ax(ax6b)
+        ax6b.axhspan(-0.5, 1.5, color=BG_HIGHLIGHT, alpha=0.75, zorder=1)
+        m6b = ["Armiger Ultra", "Armiger Priors", "Seeder Count", "All 8 Tools"]
+        v6b = [
+            p2f_whse_stats["models"]["Armiger Ultra (Fair Hybrid)"]["point_pct"],
+            p2f_whse_stats["models"]["Armiger 4-Way Priors"]["point_pct"],
+            p2f_whse_stats["models"]["Raw Seeder Count"]["point_pct"],
+            None,
+        ]
+        c6b = [C_ULTRA, C_INT8, "#64748B", "#21262D"]
+        l6b = [
+            f"{v6b[0]:.2f}% Corpus (92.42% Pub N=757)",
+            f"{v6b[1]:.2f}% Corpus (4-Way Priors)",
+            f"{v6b[2]:.2f}% Corpus (85.17% Pub N=757)",
+            "N/A (No Swarm Head)",
+        ]
+        for idx, (v, lbl) in enumerate(zip(v6b, l6b)):
+            if v is not None:
+                ax6b.barh(idx, v, height=0.6, color=c6b[idx], zorder=3)
+                ax6b.text(v + 0.8, idx, lbl, va="center", ha="left", fontsize=8.2, fontweight="bold" if idx < 2 else "normal", color=TEXT_MAIN if idx < 2 else "#CBD5E1")
+            else:
+                ax6b.barh(idx, 52.5, height=0.55, color="#21262D", edgecolor=TEXT_MUTED, hatch="//", zorder=2)
+                ax6b.text(49.5, idx, lbl, va="center", ha="left", fontsize=8.1, style="italic", color=TEXT_SUB)
+        ax6b.set_yticks(np.arange(len(m6b)))
+        ax6b.set_yticklabels(m6b, fontsize=9, fontweight="bold", color=TEXT_MAIN)
+        ax6b.invert_yaxis()
+        ax6b.set_xlim(48, 144)
+        ax6b.set_xticks([50, 60, 70, 80, 90, 100])
+        ax6b.set_xlabel("Multi-Source Corpus (Identical N=10,278) & Public Tracker (N=757: 92.42%)", fontsize=8.2, color=TEXT_SUB, labelpad=6)
+        ax6b.set_title("6B. Swarm Liveliness AUROC % (swarm_adapter.pt)", fontsize=10, fontweight="bold", color=TEXT_MAIN, pad=7)
+
+        sha_chart3 = save_clean_rgb_png(fig3, assets_dir / "armiger_vs_torrent_classifiers_6dims.png")
+
+        # ==========================================================================
+        # COMPUTE & RENDER CHART 4: armiger_categorical_breakdown.png
+        # ==========================================================================
+        fig4, (ax4_l, ax4_r) = plt.subplots(1, 2, figsize=(22.5, 11.2), gridspec_kw={"wspace": 0.22})
+        fig4.subplots_adjust(top=0.84, bottom=0.16, left=0.11, right=0.98)
+        fig4.suptitle(
+            "Per-Category Recall Breakdown Across All 10 Known Media & Software Categories",
+            fontsize=17, fontweight="bold", color=TEXT_MAIN, y=0.965,
+        )
+        fig4.text(
+            0.5, 0.925,
+            "Left: oct15_confirmation (Identical N = 2,835) vs. Open-Source Classifiers  |  Right: beyond_confirmation (Identical N = 1,025, LOTO Non-Circular)",
+            ha="center", fontsize=11.2, style="italic", color=TEXT_SUB, parse_math=False,
+        )
+
+        # Order for Left Panel (sorted by Armiger Ultra accuracy on oct15_confirmation)
+        oct_cat_spec = [
+            (6, "Audiobook"),
+            (2, "Adult / XXX"),
+            (1, "TV Show"),
+            (0, "Movie"),
+            (7, "Software"),
+            (3, "Music"),
+            (5, "Game"),
+            (8, "Ebook"),
+            (9, "Course"),
+            (4, "Comic"),
+        ]
+        cats_oct_labels = []
+        oct_ultra, oct_int8, oct_mimmo, oct_bit = [], [], [], []
+        chart4_oct_manifest: Dict[str, Any] = {}
+        for c_idx, c_title in oct_cat_spec:
+            mask = (y_oct_cat11 == c_idx)
+            n_c = int(np.sum(mask))
+            cats_oct_labels.append(f"{c_title} (n={n_c:,})")
+            u_v = float(np.mean(d["oct15_cat11_pred_ultra"][mask] == c_idx) * 100.0)
+            i_v = float(np.mean(d["oct15_cat11_pred_int8_hyb"][mask] == c_idx) * 100.0)
+            m_v = float(np.mean(d["oct15_cat11_pred_mimmo_bert"][mask] == c_idx) * 100.0)
+            b_v = float(np.mean(d["oct15_cat11_pred_bitmagnet"][mask] == c_idx) * 100.0)
+            oct_ultra.append(round(u_v, 2))
+            oct_int8.append(round(i_v, 2))
+            oct_mimmo.append(round(m_v, 2))
+            oct_bit.append(round(b_v, 2))
+            chart4_oct_manifest[c_title] = {
+                "n": n_c,
+                "armiger_ultra_pct": round(u_v, 2),
+                "armiger_int8_pct": round(i_v, 2),
+                "mimmo_bert_pct": round(m_v, 2),
+                "bitmagnet_pct": round(b_v, 2),
+            }
+
+        style_ax(ax4_l)
+        y_c = np.arange(len(cats_oct_labels))
+        h = 0.19
+        ax4_l.barh(y_c - 1.5 * h, oct_ultra, height=h, color=C_ULTRA, label="Armiger Ultra Fair Hybrid (95.49% Overall)", zorder=3)
+        ax4_l.barh(y_c - 0.5 * h, oct_int8, height=h, color=C_INT8, label="Armiger INT8 + ZeroCue (95.49% Overall, 95.06% Raw)", zorder=3)
+        ax4_l.barh(y_c + 0.5 * h, oct_mimmo, height=h, color="#818CF8", label="MIMMO BERT 360M (72.24% Overall on N=2,835)", zorder=3)
+        ax4_l.barh(y_c + 1.5 * h, oct_bit, height=h, color="#64748B", label="Bitmagnet Built-In (35.17% Overall on N=2,835)", zorder=3)
+        ax4_l.set_yticks(y_c)
+        ax4_l.set_yticklabels(cats_oct_labels, fontsize=10, fontweight="bold", color=TEXT_MAIN)
+        ax4_l.set_ylim(len(cats_oct_labels) - 0.35, -0.6)
+        ax4_l.set_xlim(0, 128)
+        ax4_l.set_xticks([0, 20, 40, 60, 80, 100])
+        ax4_l.set_xlabel("Per-Class Recall (%) — Identical N = 2,835 Ground-Truth Mask", fontsize=9.8, color=TEXT_SUB, labelpad=8)
+        ax4_l.set_title("1. Per-Category Recall vs. Open-Source Classifiers\n(oct15_confirmation, Identical N = 2,835)", fontsize=11.5, fontweight="bold", color=TEXT_MAIN, pad=10)
+        for idx in range(len(cats_oct_labels)):
+            ax4_l.text(oct_ultra[idx] + 1.0, idx - 1.1 * h, f"{oct_ultra[idx]:.1f}%", va="center", ha="left", fontsize=8.0, fontweight="bold", color=C_ULTRA_EDGE)
+            ax4_l.text(oct_mimmo[idx] + 1.0, idx + 0.5 * h, f"{oct_mimmo[idx]:.1f}%", va="center", ha="left", fontsize=7.6, color="#CBD5E1")
+            ax4_l.text(oct_bit[idx] + 1.0, idx + 1.5 * h, f"{oct_bit[idx]:.1f}%", va="center", ha="left", fontsize=7.6, color=TEXT_SUB)
+        ax4_l.legend(loc="upper center", bbox_to_anchor=(0.5, -0.09), ncol=2, facecolor=BG_PANEL, edgecolor=BORDER_COLOR, fontsize=8.6, labelcolor=TEXT_MAIN)
+
+        # Order for Right Panel (beyond_confirmation N=1,025 Non-Circular LOTO)
+        y_bc_cat11 = d["beyond_cat11_y_true"]
+        bc_cat_spec = [
+            (6, "Audiobook"),
+            (8, "Ebook"),
+            (4, "Comic"),
+            (0, "Movie"),
+            (1, "TV Show"),
+            (5, "Game"),
+            (7, "Software"),
+            (9, "Course"),
+            (2, "Adult / XXX"),
+            (3, "Music"),
+        ]
+        cats_bc_labels = []
+        bc_ultra, bc_int8, bc_gpt, bc_gem = [], [], [], []
+        chart4_bc_manifest: Dict[str, Any] = {}
+        for c_idx, c_title in bc_cat_spec:
+            mask = (y_bc_cat11 == c_idx)
+            n_c = int(np.sum(mask))
+            cats_bc_labels.append(f"{c_title} (n={n_c:,})")
+            u_v = float(np.mean(d["beyond_cat11_corr_ultra"][mask]) * 100.0)
+            i_v = float(np.mean(d["beyond_cat11_corr_int8_hyb"][mask]) * 100.0)
+            gp_v = float(np.mean(d["beyond_cat11_corr_gpt_noncirc"][mask]) * 100.0)
+            gm_v = float(np.mean(d["beyond_cat11_corr_gemini_noncirc"][mask]) * 100.0)
+            bc_ultra.append(round(u_v, 2))
+            bc_int8.append(round(i_v, 2))
+            bc_gpt.append(round(gp_v, 2))
+            bc_gem.append(round(gm_v, 2))
+            chart4_bc_manifest[c_title] = {
+                "n": n_c,
+                "armiger_ultra_pct": round(u_v, 2),
+                "armiger_int8_pct": round(i_v, 2),
+                "gpt_noncirc_pct": round(gp_v, 2),
+                "gemini_noncirc_pct": round(gm_v, 2),
+            }
+
+        style_ax(ax4_r)
+        ax4_r.barh(y_c - 1.5 * h, bc_ultra, height=h, color=C_ULTRA, label="Armiger Ultra Fair Hybrid (95.12% Non-Circular)", zorder=3)
+        ax4_r.barh(y_c - 0.5 * h, bc_int8, height=h, color=C_INT8, label="Armiger INT8 + ZeroCue (95.12% Non-Circular, 92.88% Raw)", zorder=3)
+        ax4_r.barh(y_c + 0.5 * h, bc_gpt, height=h, color=C_GPT, label="OpenAI GPT Fast Tier (95.12% Non-Circ | 96.59% Circ)", zorder=3)
+        ax4_r.barh(y_c + 1.5 * h, bc_gem, height=h, color=C_GEMINI, label="Google Gemini Flash (93.80% Non-Circ | 95.61% Circ)", zorder=3)
+        ax4_r.set_yticks(y_c)
+        ax4_r.set_yticklabels(cats_bc_labels, fontsize=10, fontweight="bold", color=TEXT_MAIN)
+        ax4_r.set_ylim(len(cats_bc_labels) - 0.35, -0.6)
+        ax4_r.set_xlim(0, 128)
+        ax4_r.set_xticks([0, 20, 40, 60, 80, 100])
+        ax4_r.set_xlabel("Per-Class Recall (%) — Leave-One-Teacher-Out Non-Circular Reference", fontsize=9.8, color=TEXT_SUB, labelpad=8)
+        ax4_r.set_title("2. Per-Category Recall vs. Cloud LLMs\n(beyond_confirmation, Identical N = 1,025, LOTO Non-Circular)", fontsize=11.5, fontweight="bold", color=TEXT_MAIN, pad=10)
+        for idx in range(len(cats_bc_labels)):
+            ax4_r.text(bc_ultra[idx] + 1.0, idx - 1.1 * h, f"{bc_ultra[idx]:.1f}%", va="center", ha="left", fontsize=8.0, fontweight="bold", color=C_ULTRA_EDGE)
+            ax4_r.text(bc_gpt[idx] + 1.0, idx + 0.5 * h, f"{bc_gpt[idx]:.1f}%", va="center", ha="left", fontsize=7.6, color=C_GPT)
+            ax4_r.text(bc_gem[idx] + 1.0, idx + 1.5 * h, f"{bc_gem[idx]:.1f}%", va="center", ha="left", fontsize=7.6, color=C_GEMINI)
+        ax4_r.legend(loc="upper center", bbox_to_anchor=(0.5, -0.09), ncol=2, facecolor=BG_PANEL, edgecolor=BORDER_COLOR, fontsize=8.6, labelcolor=TEXT_MAIN)
+
+        sha_chart4 = save_clean_rgb_png(fig4, assets_dir / "armiger_categorical_breakdown.png")
+    else:
+        for fn in ("armiger_vs_torrent_classifiers_6dims.png", "armiger_categorical_breakdown.png"):
+            verify_png_chunks_clean(fallback_assets / fn)
+        sha_chart3 = hashlib.sha256((fallback_assets / "armiger_vs_torrent_classifiers_6dims.png").read_bytes()).hexdigest()
+        sha_chart4 = hashlib.sha256((fallback_assets / "armiger_categorical_breakdown.png").read_bytes()).hexdigest()
+
+    # ==========================================================================
+    # FIVE-SPLIT SUMMARY TABLE STATS
+    # ==========================================================================
+    five_split_summary: Dict[str, Any] = {}
+    for sp_code, sp_label, n_exp in [
+        ("oct15", "oct15_confirmation", 2835),
+        ("fresh", "fresh_confirmation", 1402),
+        ("beyond", "beyond_confirmation", 1025),
+        ("tc2000", "tc_truespec_2000", 2000),
+        ("tc3000", "tc_truespec_multilang_3000", 3000),
+    ]:
+        y_sp = d[f"split5_{sp_code}_y_cat"]
+        sp_stats = compute_paired_panel_stats(
+            f"five_split_{sp_code}",
+            {
+                "armiger_ultra_hyb": (d[f"split5_{sp_code}_fp32_hyb_pred"] == y_sp).astype(np.float32),
+                "armiger_ultra_raw": (d[f"split5_{sp_code}_fp32_raw_pred"] == y_sp).astype(np.float32),
+                "armiger_int8_hyb": (d[f"split5_{sp_code}_int8_hyb_pred"] == y_sp).astype(np.float32),
+                "armiger_int8_raw": (d[f"split5_{sp_code}_int8_raw_pred"] == y_sp).astype(np.float32),
+            },
+            ref_model="armiger_ultra_hyb",
+            expected_n=n_exp,
+            metric_type="mean",
+        )
+        five_split_summary[sp_label] = sp_stats
+
+    # ==========================================================================
+    # WRITE CRYPTOGRAPHIC PROVENANCE MANIFEST (CHARTS_MANIFEST.json)
+    # ==========================================================================
+    repo_root = assets_dir.parent
+    prov_hashes: Dict[str, str] = {
+        "canonical_eval_vectors.json": hashlib.sha256(npz_path.read_bytes()).hexdigest(),
+        "generate_canonical_charts.py": hashlib.sha256(pathlib.Path(__file__).read_bytes()).hexdigest(),
+        "assets/armiger_vs_llms_overall_and_6dims.png": sha_chart1,
+        "assets/armiger_vs_llms_cost_comparison.png": sha_chart2,
+        "assets/armiger_vs_torrent_classifiers_6dims.png": sha_chart3,
+        "assets/armiger_categorical_breakdown.png": sha_chart4,
+    }
+    for opt_rel in [
+        "validated_zero_cue_catalog.json",
+        "armiger_ultra.fp32.onnx",
+        "armiger.int8.onnx",
+        "models/armiger_ultra.fp32.onnx",
+        "models/armiger.int8.onnx",
+    ]:
+        p_opt = repo_root / opt_rel
+        if p_opt.is_file():
+            prov_hashes[opt_rel] = hashlib.sha256(p_opt.read_bytes()).hexdigest()
+
+    manifest: Dict[str, Any] = {
+        "schema_version": "1.0.0",
+        "bootstrap_seed": BOOTSTRAP_SEED,
+        "bootstrap_resamples": BOOTSTRAP_RESAMPLES,
+        "invariants_verified": {
+            "identical_denominator_lock": True,
+            "anti_circularity_lock": True,
+            "paired_uncertainty_and_significance": True,
+            "png_metadata_stripped_ihdr_idat_iend_only": True,
+        },
+        "anti_circularity_audit": anti_circ_checks,
+        "provenance_sha256": prov_hashes,
+        "charts": {
+            "armiger_vs_llms_overall_and_6dims.png": {
+                "sha256": sha_chart1,
+                "composite_6dim_mean": composite_stats,
+                "panel_2a_category_11class": p2a_stats,
+                "panel_2b_catalog_matching": p2b_stats,
+                "panel_2c_audio_strict_229": p2c_stats,
+                "panel_2d_anime_valid_636": p2d_stats,
+                "panel_2e_junk_balanced_977": p2e_stats,
+                "panel_2f_swarm_public_757": p2f_pub_stats,
+                "panel_2f_swarm_warehouse_10278": p2f_whse_stats,
+            },
+            "armiger_vs_llms_cost_comparison.png": {
+                "sha256": sha_chart2,
+                "models": models_cost,
+                "batched_usd_per_1m": batched_cost,
+                "realtime_usd_per_1m": realtime_cost,
+            },
+            "armiger_vs_torrent_classifiers_6dims.png": {
+                "sha256": sha_chart3,
+                "panel_1_category_11class_oct15": c3_p1_stats,
+                "panel_1_video_mvtv_oct15": c3_p1_vid_stats,
+                "panel_2_catalog_matching_oct15": c3_p2_stats,
+                "panel_3_audio_strict_oct15": c3_p3_stats,
+                "panel_4_anime_oct15": c3_p4_oct_stats,
+                "panel_4_anime_dub_tc2000": c3_p4_tc2k_stats,
+                "panel_5_adult_oct15": c3_p5_stats,
+                "panel_6a_junk_oct15": c3_p6a_stats,
+            },
+            "armiger_categorical_breakdown.png": {
+                "sha256": sha_chart4,
+                "left_oct15_confirmation_n2835": chart4_oct_manifest,
+                "right_beyond_confirmation_n1025_loto": chart4_bc_manifest,
+            },
+        },
+        "five_split_category_summary": five_split_summary,
+    }
+    manifest_path.parent.mkdir(parents=True, exist_ok=True)
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=False) + "\n", encoding="utf-8")
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate canonical Armiger benchmark charts and CHARTS_MANIFEST.json.")
+    here = pathlib.Path(__file__).resolve().parent
+    parser.add_argument("--vectors", type=pathlib.Path, default=here / "canonical_eval_vectors.json")
+    parser.add_argument("--assets-dir", type=pathlib.Path, default=here.parent / "assets")
+    parser.add_argument("--manifest", type=pathlib.Path, default=here / "CHARTS_MANIFEST.json")
+    args = parser.parse_args()
+
+    manifest = build_all_charts_and_manifest(args.vectors, args.assets_dir, args.manifest)
+    for name, info in manifest["charts"].items():
+        print(f"[OK] {name:46s} sha256={info['sha256'][:16]}...")
+    print(f"[OK] Wrote {args.manifest}")
+
+
+if __name__ == "__main__":
+    main()

benchmarks/test_chart_integrity.py

@@ -0,0 +1,192 @@
+"""
+Automated integrity and statistical invariant test suite for the canonical
+Armiger & Armiger Ultra chart and benchmark pipeline.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import pathlib
+import sys
+
+import numpy as np
+import pytest
+
+BENCH_DIR = pathlib.Path(__file__).resolve().parent
+REPO_ROOT = BENCH_DIR.parent
+if str(BENCH_DIR) not in sys.path:
+    sys.path.insert(0, str(BENCH_DIR))
+
+
+def _load_vectors(path: pathlib.Path):
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    dtypes = raw["_meta"]["dtypes"]
+    return {k: np.array(v, dtype=np.dtype(dtypes[k])) for k, v in raw["vectors"].items()}
+
+from generate_canonical_charts import (  # noqa: E402
+    BOOTSTRAP_RESAMPLES,
+    BOOTSTRAP_SEED,
+    HAS_MATPLOTLIB,
+    assert_identical_denominator,
+    assert_non_circular_teacher_eval,
+    build_all_charts_and_manifest,
+    compute_paired_panel_stats,
+    verify_png_chunks_clean,
+)
+
+
+def test_identical_denominator_lock_enforced():
+    """Verify that any denominator mismatch across models on a panel raises AssertionError."""
+    v_1025 = np.ones(1025, dtype=np.float32)
+    v_1009 = np.ones(1009, dtype=np.float32)  # Dropped 16 'unknown' items
+    v_2835 = np.ones(2835, dtype=np.float32)
+    v_2825 = np.ones(2825, dtype=np.float32)  # Dropped 10 'unknown' items
+    v_545 = np.ones(545, dtype=np.float32)
+    v_849 = np.ones(849, dtype=np.float32)    # Mismatched audio language split
+
+    assert assert_identical_denominator("ok_1025", {"ultra": v_1025, "gpt": v_1025}, expected_n=1025) == 1025
+
+    with pytest.raises(AssertionError, match="Identical Denominator Lock violated"):
+        assert_identical_denominator("bad_beyond_unknown_drop", {"ultra": v_1025, "gpt": v_1009})
+
+    with pytest.raises(AssertionError, match="Identical Denominator Lock violated"):
+        assert_identical_denominator("bad_oct15_unknown_drop", {"ultra": v_2835, "mimmo": v_2825})
+
+    with pytest.raises(AssertionError, match="Identical Denominator Lock violated"):
+        assert_identical_denominator("bad_audio_split_mix", {"ultra": v_545, "gpt": v_849})
+
+    with pytest.raises(AssertionError, match="Expected N=636"):
+        assert_identical_denominator("bad_expected_n", {"ultra": np.ones(650), "gpt": np.ones(650)}, expected_n=636)
+
+    v_nan = v_1025.copy()
+    v_nan[0] = np.nan
+    with pytest.raises(AssertionError, match="NaN"):
+        assert_identical_denominator("bad_nan", {"ultra": v_1025, "gpt": v_nan})
+
+
+def test_anti_circularity_lock_enforced():
+    """Verify that scoring a teacher model against its own circular majority vote raises AssertionError."""
+    d = _load_vectors(BENCH_DIR / "canonical_eval_vectors.json")
+
+    with pytest.raises(AssertionError, match="Anti-Circularity Lock violated"):
+        assert_non_circular_teacher_eval("OpenAI GPT (Fast Tier)", eval_mode="circular_majority", self_vote_weight=0.333)
+
+    with pytest.raises(AssertionError, match="Anti-Circularity Lock violated"):
+        assert_non_circular_teacher_eval("Google Gemini Flash", eval_mode="leave_one_teacher_out", self_vote_weight=0.5)
+
+    gpt_audit = assert_non_circular_teacher_eval(
+        "OpenAI GPT (Fast Tier)",
+        eval_mode="leave_one_teacher_out",
+        self_vote_weight=0.0,
+        noncirc_vec=d["beyond_cat11_corr_gpt_noncirc"],
+        circ_vec=d["beyond_cat11_corr_gpt_circ"],
+    )
+    assert gpt_audit["non_circular_pct"] == 95.12
+    assert gpt_audit["circular_self_vote_pct"] == 96.59
+    assert gpt_audit["circularity_inflation_pp"] > 1.0
+
+    gem_audit = assert_non_circular_teacher_eval(
+        "Google Gemini Flash",
+        eval_mode="leave_one_teacher_out",
+        self_vote_weight=0.0,
+        noncirc_vec=d["beyond_cat11_corr_gemini_noncirc"],
+        circ_vec=d["beyond_cat11_corr_gemini_circ"],
+    )
+    assert gem_audit["non_circular_pct"] == 93.80
+    assert gem_audit["circular_self_vote_pct"] == 95.61
+    assert gem_audit["circularity_inflation_pp"] > 1.5
+
+
+def test_eval_vectors_privacy_and_dtypes():
+    """Verify that canonical_eval_vectors.json contains only numeric int16/float32 arrays and zero strings."""
+    npz_path = BENCH_DIR / "canonical_eval_vectors.json"
+    assert npz_path.is_file()
+    d = _load_vectors(npz_path)
+    assert len(list(d.keys())) >= 140
+    for k in list(d.keys()):
+        arr = d[k]
+        assert arr.dtype in (np.int16, np.float32), f"Array {k} has disallowed dtype {arr.dtype}"
+        assert arr.ndim == 1, f"Array {k} must be 1D, got shape {arr.shape}"
+        assert not np.isnan(arr).any(), f"Array {k} contains NaNs"
+
+
+def test_paired_bootstrap_and_mcnemar_reproducibility():
+    """Verify that paired bootstrap 95% CIs and McNemar p-values are 100% deterministic."""
+    d = _load_vectors(BENCH_DIR / "canonical_eval_vectors.json")
+    vecs = {
+        "Armiger Ultra": (d["oct15_aud545_pred_ultra"] == d["oct15_aud545_y_en"]).astype(np.float32),
+        "Armiger INT8": (d["oct15_aud545_pred_int8_hyb"] == d["oct15_aud545_y_en"]).astype(np.float32),
+        "GuessIt": (d["oct15_aud545_pred_guessit"] == d["oct15_aud545_y_en"]).astype(np.float32),
+        "OpenAI GPT (Fast Tier)": (d["oct15_aud545_pred_gpt"] == d["oct15_aud545_y_en"]).astype(np.float32),
+    }
+    res1 = compute_paired_panel_stats("test_aud545", vecs, ref_model="Armiger Ultra", expected_n=545)
+    res2 = compute_paired_panel_stats("test_aud545", vecs, ref_model="Armiger Ultra", expected_n=545)
+    assert res1 == res2
+    for m, st in res1["models"].items():
+        assert st["n"] == 545
+        assert st["ci95_lo"] <= st["point_pct"] <= st["ci95_hi"]
+        assert 0.0 <= st["p_value_vs_ref"] <= 1.0
+    assert res1["models"]["Armiger Ultra"]["point_pct"] == 97.80
+    assert res1["models"]["GuessIt"]["point_pct"] == 94.86
+    assert res1["models"]["OpenAI GPT (Fast Tier)"]["point_pct"] == 94.68
+    assert res1["models"]["OpenAI GPT (Fast Tier)"]["p_value_vs_ref"] < 0.01
+
+
+def test_manifest_sha256_and_png_chunks(tmp_path: pathlib.Path):
+    """Verify CHARTS_MANIFEST.json provenance hashes, PNG chunk hygiene, and byte-exact determinism."""
+    manifest_path = BENCH_DIR / "CHARTS_MANIFEST.json"
+    assert manifest_path.is_file(), "CHARTS_MANIFEST.json missing"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+
+    assert manifest["bootstrap_seed"] == BOOTSTRAP_SEED
+    assert manifest["bootstrap_resamples"] == BOOTSTRAP_RESAMPLES
+    for k, v in manifest["invariants_verified"].items():
+        assert v is True, f"Invariant {k} not verified"
+
+    # Verify all provenance SHA-256 hashes match disk
+    for rel_path, expected_sha in manifest["provenance_sha256"].items():
+        target = (BENCH_DIR / rel_path) if (BENCH_DIR / rel_path).is_file() else (REPO_ROOT / rel_path)
+        assert target.is_file(), f"Provenance file missing: {rel_path}"
+        actual_sha = hashlib.sha256(target.read_bytes()).hexdigest()
+        assert actual_sha == expected_sha, f"SHA-256 mismatch for {rel_path}: {actual_sha} != {expected_sha}"
+
+    # Verify all 4 PNGs have only IHDR, IDAT, IEND chunks and RGB mode
+    for chart_name, chart_meta in manifest["charts"].items():
+        png_path = REPO_ROOT / "assets" / chart_name
+        assert png_path.is_file(), f"Chart missing: {png_path}"
+        chunks = verify_png_chunks_clean(png_path)
+        assert chunks[0] == "IHDR" and chunks[-1] == "IEND"
+        assert set(chunks).issubset({"IHDR", "IDAT", "IEND"})
+
+    # Re-run pipeline into tmp_path and verify statistical + PNG determinism
+    tmp_assets = tmp_path / "assets"
+    tmp_manifest = tmp_path / "CHARTS_MANIFEST.json"
+    render_mode = bool(HAS_MATPLOTLIB and sys.platform == "darwin")
+    re_manifest = build_all_charts_and_manifest(
+        BENCH_DIR / "canonical_eval_vectors.json",
+        tmp_assets,
+        tmp_manifest,
+        render_pngs=render_mode,
+    )
+    assert re_manifest["invariants_verified"] == manifest["invariants_verified"]
+    assert re_manifest["anti_circularity_audit"] == manifest["anti_circularity_audit"]
+    assert re_manifest["five_split_category_summary"] == manifest["five_split_category_summary"]
+    for chart_name, chart_meta in manifest["charts"].items():
+        assert re_manifest["charts"][chart_name] == chart_meta, (
+            f"Non-deterministic manifest or PNG output for {chart_name}"
+        )
+
+
+def test_readme_tables_match_charts_manifest():
+    """Verify README.md contains canonical CHARTS_MANIFEST.json metrics and zero stale numbers."""
+    readme_path = REPO_ROOT / "README.md"
+    assert readme_path.is_file()
+    text = readme_path.read_text(encoding="utf-8")
+
+    # Canonical numbers that must appear in README
+    for required_token in ("95.49%", "97.30%", "96.53%", "97.80%", "96.83%"):
+        assert required_token in text, f"Missing canonical metric {required_token} in {readme_path}"
+
+    # Stale pre-audit numbers that must never reappear in README
+    for stale_token in ("97.13%", "96.35%", "72.35%", "35.29%", "97.55%"):
+        assert stale_token not in text, f"Stale metric {stale_token} found in {readme_path}"

config.json

@@ -62,16 +62,16 @@
   },
   "artifacts": {
     "csam_guard.py": {
-      "size_bytes": 42555,
-      "sha256": "fa96e13ad86e50451b668ac10275a7afa472111a9449f2183c7a253d34d3776c"
+      "size_bytes": 44802,
+      "sha256": "b76eff993f86f2a08c2aecaa39a4109b57f40be1d1b2b0066803e10cb33a0f96"
     },
     "armiger_dht_db_sync.py": {
-      "size_bytes": 51391,
-      "sha256": "4ef834f352b3725be2e5d92ce6c29f92f59ef0e5c584971a9d26954ad9502539"
+      "size_bytes": 69631,
+      "sha256": "27107c7a49e79ab0874c50881e42d742dc91d57dc049d11898dd4d04efa9bed1"
     },
     "test_dht_db_sync.py": {
       "size_bytes": 62482,
-      "sha256": "ed6cebbcbaebc0d43516f68952937696a6b6c88ec54da8536112f9127b4f4290"
+      "sha256": "c6a58c19ca3d698405132f46bde74ce038639b08c06ba9f00f2cee1f1dfdaf8f"
     }
   }
 }

csam_guard.py

@@ -848,9 +848,13 @@ class WOTSPlusSHAKE256:
         return digits
 
     @classmethod
-    @functools.lru_cache(maxsize=256)
     def generate_keypair(cls, seed: Optional[bytes] = None) -> Tuple[bytes, bytes]:
         raw = seed if seed is not None else os.urandom(64)
+        return cls._generate_keypair_from_seed(raw)
+
+    @classmethod
+    @functools.lru_cache(maxsize=256)
+    def _generate_keypair_from_seed(cls, raw: bytes) -> Tuple[bytes, bytes]:
         if len(raw) == 32:
             raw = hashlib.shake_256(b"armiger-wots-keygen-v1:" + raw).digest(64)
         elif len(raw) != 64:

docs/ANONYMOUS_OPT_IN_DHT.md

@@ -1,6 +1,6 @@
 # Armiger Distributed Anonymous & Opt-In-By-Default DHT Sharing
 
-This document specifies the cryptographic, differential-privacy, and wire-level firewall architecture governing distributed weight, calibration, and catalog metadata sharing in **Armiger** and **Armiger Ultra** (`armiger_dht_rsi.py`, `armiger_dht_db_sync.py`, `armiger_ultra_pipeline.py`), along with the machine-verifiable results from the live 12-node UDP BEP-44 proof suite (`benchmarks/proof_anonymous_opt_in_sharing.py`).
+This document specifies the cryptographic, differential-privacy, and wire-level firewall architecture governing distributed weight, calibration, and catalog metadata sharing in **Armiger** and **Armiger Ultra** (`armiger_dht_rsi.py`, `armiger_dht_db_sync.py`, `armiger_ultra_pipeline.py`), along with the machine-verifiable results from the 12-node local UDP BEP-44 proof & synthetic DP convergence suite (`benchmarks/proof_anonymous_opt_in_sharing.py`).
 
 ---
 
@@ -61,7 +61,7 @@ Whenever an operator explicitly opts in (`opt_in_sharing=True` or `ARMIGER_DHT_S
 
 ---
 
-## 3. Live 12-Node UDP BEP-44 Verification Summary
+## 3. 12-Node Local UDP BEP-44 & Synthetic DP Convergence Verification Summary
 
 Reproduce all three proofs locally with:
 
@@ -74,4 +74,4 @@ pytest test_anonymous_opt_in_dht_sharing.py
 | :--- | :--- | :--- | :--- |
 | **Proof 1: Default Zero-Egress** | 9 default components, 100 synthetic webhook/catalog events | `opt_in_sharing=False` on 9/9; `0` bundles & `0` UDP `put` packets emitted (`2,600` outbound attempts blocked) | **PASS** |
 | **Proof 2: Wire Canary Firewall** | 500 adversarial PII/canary payloads across 10 categories on 12-node UDP swarm | `500 / 500` (`100.0%`) blocked before wire; `0 / 500` (`0.0%`) canary substrings in raw UDP datagrams | **PASS** |
-| **Proof 3: Unlinkability & DP Convergence** | 12-node UDP swarm over 5 epochs (60 publications) | `60 / 60` unique ephemeral Ed25519 keys (`8.33%` random linkability); `100%` hour-bucketed timestamps; MIA accuracy `0.545`; ECE `0.08094 -> 0.01300` (`-83.94%`); Ultra F1 `0.93427 -> 0.98074` | **PASS** |
+| **Proof 3: Unlinkability & Synthetic DP Convergence** | 12-node local UDP swarm over 5 epochs (60 publications, synthetic adapter + temperature convergence) | `60 / 60` unique ephemeral Ed25519 keys (`8.33%` random linkability); `100%` hour-bucketed timestamps; MIA empirical accuracy `0.590`; ECE `0.08094 -> 0.01368` (`-83.10%`); Ultra F1 `0.93427 -> 0.98004` | **PASS** |

docs/CHART_PIPELINE.md

@@ -0,0 +1,57 @@
+# Canonical Statistical Chart & Benchmark Pipeline (`v2.1.0`)
+
+Every benchmark figure and headline accuracy table across the **Armiger** and **Armiger Ultra** repositories is generated deterministically from anonymized evaluation vectors (`benchmarks/canonical_eval_vectors.json`) and locked by a cryptographic provenance manifest (`benchmarks/CHARTS_MANIFEST.json`).
+
+---
+
+## 1. Pipeline Architecture & Artifacts
+
+| Artifact | SHA-256 Digest | Description |
+| :--- | :--- | :--- |
+| `benchmarks/canonical_eval_vectors.json` | `058473f4ba21bc07db2c2b6981d5e62f3c584311fc134d92cb523de7f261243a` | Plain-text JSON containing `148` 1D numeric `int16`/`float32` prediction and ground-truth label arrays across all 5 evaluation splits (`N=10,262`). Contains **zero** strings, release titles, file paths, or infohashes. |
+| `benchmarks/generate_canonical_charts.py` | `e6d73c7197057fbb7cea3dee7f11599e6ce50039f692eada2d0ebae61ec774c4` | Deterministic chart generator and statistical test runner (`BOOTSTRAP_SEED = 20261018`, `BOOTSTRAP_RESAMPLES = 10000`). |
+| `benchmarks/CHARTS_MANIFEST.json` | *(Tracked by `test_chart_integrity.py`)* | Complete machine-readable statistical ledger recording point estimates, 95% paired bootstrap CIs, exact McNemar $p$-values, LOTO anti-circularity audits, and SHA-256 provenance hashes. |
+| `assets/armiger_vs_llms_overall_and_6dims.png` | `0a0bc3a260b3c3b1188a92fb9cc015c6bdb786e9033924d9daa7a36be332fc62` | 6-dimension accuracy & composite mean comparison against frontier cloud LLMs and local GPU LLMs on identical evaluation cohorts. |
+| `assets/armiger_vs_llms_cost_comparison.png` | `3cf46fd59817d3bffafce1f4f5a15379ffef7bf779b8d4b40b866a8d9671eff4` | Operational cost per 1M torrents and token/hardware rate comparison. |
+| `assets/armiger_vs_torrent_classifiers_6dims.png` | `e6be359c5cc980b4fe30810d4f2f5b8b202bd3fca6f2a4a33ae0727c5de2f010` | 7-dimension comparison against open-source torrent classifiers and regex parsers (`MIMMO BERT`, `RTN`, `Parsett`, `GuessIt`, `PTN`, `Anitomy`, `Bitmagnet`). |
+| `assets/armiger_categorical_breakdown.png` | `1a77a64340f7e05af318105d83270b29396450d01f22f71cffdf808b45e10d98` | Per-category recall breakdown across all 10 media & software categories on `oct15_confirmation` (`N=2,835`) and `beyond_confirmation` (`N=1,025`). |
+
+---
+
+## 2. Four Machine-Enforced Statistical Invariants
+
+`benchmarks/test_chart_integrity.py` enforces four strict invariants on every CI run:
+
+### Invariant 1 — Identical Denominator Lock (`assert_identical_denominator`)
+Every model compared on a benchmark panel must be evaluated on the **exact same item mask and denominator $N$**. Dropping abstentions (`unknown`), mixing evaluation splits, or evaluating on a subset raises an immediate `AssertionError`:
+- `oct15_confirmation` 11-Class Category: $N = 2,835$
+- `beyond_confirmation` 11-Class Category & Catalog Matching: $N = 1,025$
+- `oct15_confirmation` Movie-vs-TV & Catalog Matching: $N = 1,296$
+- `oct15_confirmation` Binary English-vs-Foreign Audio: $N = 545$ (`beyond_confirmation` strict audio: $N = 229$)
+- `oct15_confirmation` Anime Detection: $N = 507$ (`beyond_confirmation` valid media: $N = 636$)
+- `oct15_confirmation` Junk / Malware Gate: $N = 2,170$ (`beyond_confirmation`: $N = 977$)
+- `Chart 1 Panel 2F` Swarm Liveliness AUROC: $N = 757$ Public-Tracker Cohort across all 6 compared systems (`Chart 3 Panel 6B`: $N = 10,278$ Multi-Source Corpus across all 3 compared methods)
+
+### Invariant 2 — Anti-Circularity Lock (`assert_non_circular_teacher_eval`)
+On `beyond_confirmation` ($N = 1,025$), where multi-teacher consensus contributed to reference curation, teacher models (`OpenAI GPT (Fast Tier)` and `Google Gemini Flash`) are strictly evaluated against **Leave-One-Teacher-Out (LOTO)** reference keys (`self_vote_weight = 0.0`):
+
+| Teacher Model | Non-Circular LOTO Accuracy (`self_vote_weight = 0.0`) | Circular Self-Voted Accuracy | Removed Circularity Inflation |
+| :--- | :---: | :---: | :---: |
+| `OpenAI GPT (Fast Tier)` | **`95.12%`** | `96.59%` | `+1.46 pp` |
+| `Google Gemini Flash` | **`93.80%`** | `95.61%` | `+1.80 pp` |
+
+Scoring any teacher model with `self_vote_weight > 0.0` or `eval_mode != "leave_one_teacher_out"` raises an `AssertionError`.
+
+### Invariant 3 — Paired Bootstrap 95% CIs, Hájek/DeLong AUROC CIs & Exact McNemar $p$-Values (`compute_paired_panel_stats`)
+All accuracy uncertainty intervals and significance tests are paired by item index across `10,000` bootstrap resamples (`seed = 20261018`) using integer-scaled `float64` dot products (eliminating BLAS thread non-determinism across macOS ARM64 and Linux x86_64), two-sample Hájek/DeLong rank-placement variance for AUROC panels, and exact binomial `math.comb` McNemar two-sided $p$-values.
+
+### Invariant 4 — Cryptographic PNG Hygiene (`verify_png_chunks_clean`)
+Every generated PNG is stripped of non-deterministic metadata (`tEXt`, `iTXt`, `zTXt`, `tIME`, `pHYs`) so only `IHDR`, `IDAT`, and `IEND` chunks remain, guaranteeing byte-exact reproducibility.
+
+---
+
+## 3. Running Verification Locally
+
+```bash
+pytest benchmarks/test_chart_integrity.py -v
+```

docs/INTEGRATION_GUIDE.md

@@ -0,0 +1,282 @@
+# Armiger & Armiger Ultra Ecosystem Integration Guide
+
+This guide provides step-by-step instructions, turnkey Docker Compose stacks, and reference HTTP adapters for integrating **Armiger** (`8.3 MB INT8 CPU`) and **Armiger Ultra** (`32.3 MB FP32 GPU/CPU` + 6 official plugins) with:
+
+1. **[Part A — Integrating with `DH-Waypoint`](#part-a--integrating-armiger-with-dh-waypoint)** (`https://github.com/spencernorton/DH-Waypoint`):
+   - Native `dh-waypoint.processor.v1` processor contract (`GET /v1/manifest`, `GET /v1/status`, `POST /v1/process`, and batch `POST /v1/classify`)
+   - Pre-ingest `dh-waypoint.processors.admission.v1` cohort admission gate (`POST /v1/admit`)
+   - Closed-loop 4-tier `dh-waypoint.processors.feedback.v1` outcome telemetry (`POST /v1/feedback`)
+2. **[Part B — Integrating with `Bitmagnet`](#part-b--integrating-armiger-with-bitmagnet)**:
+   - Pre-ingest / post-crawl batch classifier & malware/honeypot pruner (`examples/bitmagnet/bitmagnet_armiger_bridge.py`)
+   - GraphQL `torrentDelete` / content enrichment bridge & Torznab proxy enrichment
+3. **[Part C — Integrating with Torznab Index Consumers (`Prowlarr`, `Sonarr`, `Radarr`, `Lidarr`, `Readarr`) & `qBittorrent`](#part-c--integrating-armiger-with-torznab-index-consumers--qbittorrent)**:
+   - Pre-grab Torznab filtering proxy (`examples/arr-stack/armiger_torznab_proxy.py`) blocking disguised `.exe`/`.scr`/`.lnk` malware, fake-seeder honeypot traps, dead swarms, and unrequested foreign-language audio tracks before grab
+   - Post-import webhook & `ffprobe` physical ground-truth receiver (`examples/arr-stack/armiger_arr_webhook_receiver.py`) wired into `SeriesWebhookAdapter`, `MovieWebhookAdapter`, `AudioWebhookAdapter`, `PublicationWebhookAdapter`, `QBittorrentAdapter`, and `PhysicalGroundTruthVerifier` for local conformal calibration and opt-in anonymous `BEP-44`/`BEP-46` RSI knowledge sharing
+
+---
+
+## Architecture Overview
+
+```mermaid
+flowchart LR
+    subgraph Indexers["DHT Indexers & Crawlers"]
+        DHW["DH-Waypoint Core<br/>(processorapi/v1)"]
+        BM["Bitmagnet<br/>(GraphQL + Torznab)"]
+        PR["Prowlarr<br/>(Indexer Manager)"]
+    end
+
+    subgraph ArmigerSuite["Armiger / Armiger Ultra"]
+        PROC["Armiger Waypoint Processor<br/>(/v1/manifest, /v1/process, /v1/classify, /v1/admit, /v1/feedback)"]
+        BMBR["Bitmagnet Armiger Bridge<br/>(/v1/bitmagnet/classify)"]
+        TPROXY["Armiger Torznab Proxy<br/>(Port 8097 Admission Gate)"]
+        WHOOK["Armiger Webhook & ffprobe Receiver<br/>(Port 8098 Ground Truth + BEP-44 RSI)"]
+    end
+
+    subgraph ArrStack["*Arr Media Managers & Download Client"]
+        SON["Sonarr / Radarr / Lidarr / Readarr"]
+        QBT["qBittorrent / Transmission"]
+    end
+
+    DHW <-->|"HTTP processorapi/v1"| PROC
+    BM <-->|"Batch Classify + GraphQL Prune"| BMBR
+    DHW -->|"Torznab Feed"| TPROXY
+    BM -->|"Torznab Feed"| TPROXY
+    PR -->|"Torznab Feed"| TPROXY
+    TPROXY -->|"Sanitized & Enriched XML"| SON
+    SON -->|"Grab Approved Release"| QBT
+    SON -->|"On Import Webhook"| WHOOK
+    QBT -->|"On Completion + ffprobe"| WHOOK
+    WHOOK -.->|"Local Calibration & Opt-In BEP-44 RSI"| PROC
+```
+
+---
+
+## Part A — Integrating Armiger with `DH-Waypoint`
+
+[`DH-Waypoint`](https://github.com/spencernorton/DH-Waypoint) includes a built-in external processor subsystem (`processorapi/v1`) that connects directly to [`examples/dh-waypoint/armiger_waypoint_processor.py`](../examples/dh-waypoint/armiger_waypoint_processor.py).
+
+### 1. Turnkey Docker Compose Stack
+
+Launch `DH-Waypoint`, `PostgreSQL`, and `Armiger Ultra` together using [`examples/dh-waypoint/docker-compose.yml`](../examples/dh-waypoint/docker-compose.yml):
+
+```bash
+export POSTGRES_PASSWORD="<postgres-password>"
+docker compose -f examples/dh-waypoint/docker-compose.yml up -d
+```
+
+### 2. Drop-In Plugin Manifest (`07-armiger-ultra.plugin.yml`)
+
+Mount [`examples/dh-waypoint/07-armiger-ultra.plugin.yml`](../examples/dh-waypoint/07-armiger-ultra.plugin.yml) into `DH_WAYPOINT_PROCESSORS_PLUGIN_DIR` (`/etc/dh-waypoint/plugins.d/07-armiger-ultra.plugin.yml`):
+
+```yaml
+processor:
+  name: armiger-ultra
+  endpoint: http://armiger-ultra:8095/v1/classify
+  timeout: 5s
+  max_batch: 64
+  required: false
+  forward_files: true
+  max_files: 64
+  forward_trackers: true
+  forward_swarm: true
+
+admission:
+  enabled: true
+  endpoint: http://armiger-ultra:8095/v1/admit
+  timeout: 3s
+  max_batch: 64
+  max_files: 64
+  fail_open: true
+
+learning:
+  enabled: true
+  feedback_endpoint: http://armiger-ultra:8095/v1/feedback
+  feedback_timeout: 5s
+  feedback_batch_size: 64
+  flush_interval: 15s
+  queue_size: 2048
+```
+
+### 3. Equivalent `DH_WAYPOINT_*` Environment Variables
+
+If you configure `DH-Waypoint` via environment variables instead of `plugins.d`:
+
+| Variable | Recommended Value | Purpose |
+| :--- | :--- | :--- |
+| `DH_WAYPOINT_PROCESSORS_HTTP_CHAIN` | `armiger-ultra=http://armiger-ultra:8095/v1/classify` | Ordered HTTP classification chain (`dh-waypoint.processor.v1`). |
+| `DH_WAYPOINT_PROCESSORS_HTTP_FORWARD_FILES` | `true` | Forwards physical file paths and byte sizes to Armiger's File-Tree Encoder. |
+| `DH_WAYPOINT_PROCESSORS_HTTP_FORWARD_TRACKERS` | `true` | Forwards tracker domain hints to `SwarmPriors`. |
+| `DH_WAYPOINT_PROCESSORS_HTTP_FORWARD_SWARM` | `true` | Forwards seeder/leecher counts to `SwarmSurvivalNet`. |
+| `DH_WAYPOINT_PROCESSORS_ADMISSION_ENABLED` | `true` | Enables pre-ingest cohort admission (`dh-waypoint.processors.admission.v1`). |
+| `DH_WAYPOINT_PROCESSORS_ADMISSION_ENDPOINT` | `http://armiger-ultra:8095/v1/admit` | Pre-ingest admission endpoint. |
+| `DH_WAYPOINT_LEARNING_ENABLED` | `true` | Enables the 4-tier `dh-waypoint.processors.feedback.v1` outcome loop. |
+| `DH_WAYPOINT_LEARNING_FEEDBACK_ENDPOINT` | `http://armiger-ultra:8095/v1/feedback` | Delivers `t1_discovery` through `t4_playback` feedback batches to Armiger. |
+
+---
+
+## Part B — Integrating Armiger with `Bitmagnet`
+
+Upstream `Bitmagnet` uses deterministic keyword/extension rules (`35.17%` 11-class accuracy on `N=10,262` audited torrents). Deploying [`examples/bitmagnet/bitmagnet_armiger_bridge.py`](../examples/bitmagnet/bitmagnet_armiger_bridge.py) upgrades a `Bitmagnet` deployment to **`95.49%` 11-class accuracy** (`97.60%` 6-dimension composite accuracy) and **`100%` fake-seeder malware trap recall**.
+
+### 1. Turnkey `Bitmagnet` + `Armiger` Docker Compose Stack
+
+Start the stack in [`examples/bitmagnet/docker-compose.yml`](../examples/bitmagnet/docker-compose.yml):
+
+```bash
+export POSTGRES_PASSWORD="<postgres-password>"
+docker compose -f examples/bitmagnet/docker-compose.yml up -d
+```
+
+This launches two companion services alongside `bitmagnet`:
+- **`armiger-bitmagnet-bridge` (`port 8096`)**: Evaluates batches of newly crawled Bitmagnet torrents (`POST /v1/bitmagnet/classify`), maps Armiger's 11-class predictions (`movie`, `tv_show`, `music`, `ebook`, `audiobook`, `comic`, `software`, `game`, `xxx`) and tags (`armiger:<category>`, `armiger:lang:<lang>`, `armiger:viability:<tier>`) onto Bitmagnet items, and automatically executes Bitmagnet's GraphQL `torrent.delete` mutation against disguised malware payloads (`.mkv.exe`, `.scr`, `.lnk`, `.vbs`) and fake-seeder honeypots.
+- **`armiger-torznab-proxy` (`port 8097`)**: Wraps `http://bitmagnet:3333/torznab` with real-time neural admission filtering before `Prowlarr`, `Sonarr`, or `Radarr` sees search results.
+
+### 2. Calling the Bitmagnet Classifier Bridge Directly
+
+```bash
+curl -sS -X POST http://localhost:8096/v1/bitmagnet/classify \
+  -H "Content-Type: application/json" \
+  -d '{
+    "torrents": [
+      {
+        "infoHash": "1111222233334444555566667777888899990000",
+        "name": "Sintel.2010.2160p.UHD.Master.HEVC.FLAC.5.1-OPEN",
+        "size": 74500000000,
+        "seeders": 320,
+        "leechers": 18,
+        "files": [{"path": "Sintel.2010.2160p.mkv", "size": 74500000000}]
+      },
+      {
+        "infoHash": "aaaa22223333444455556666777788889999bbbb",
+        "name": "Big.Buck.Bunny.2008.1080p.WEBM.mkv.exe",
+        "size": 15400000,
+        "seeders": 4500,
+        "leechers": 12,
+        "files": [{"path": "Big.Buck.Bunny.2008.1080p.WEBM.mkv.exe", "size": 15400000}]
+      }
+    ]
+  }'
+```
+
+The bridge classifies the first item as `contentType: "movie"` (`viabilityTier: "alive_viable"`) and flags the second item (`Big.Buck.Bunny.2008.1080p.WEBM.mkv.exe`) for immediate deletion via `graphqlDeleteMutation`.
+
+---
+
+## Part C — Integrating Armiger with Torznab Index Consumers & `qBittorrent`
+
+Armiger integrates with standard Torznab XML/RSS index consumers (`Prowlarr`, `Sonarr`, `Radarr`, `Lidarr`, `Readarr`) and BitTorrent clients (`qBittorrent`, `Transmission`) at **two stages**:
+1. **Stage 1 — Pre-Grab Torznab Filtering Proxy (`port 8097`):** Blocks malware masquerades, fake-seeder honeypots, dead swarms, and unrequested foreign-language audio releases *before* any `*Arr` app grabs them.
+2. **Stage 2 — Post-Import Webhook & `ffprobe` Ground-Truth Receiver (`port 8098`):** Verifies completed downloads and `ffprobe` media streams to calibrate local Mondrian thresholds and optionally contribute differential-privacy blinded telemetry to the `BEP-44`/`BEP-46` RSI network.
+
+### 1. Stage 1: Wiring the Torznab Filtering Proxy (`Prowlarr` / `Sonarr` / `Radarr` / `Lidarr` / `Readarr`)
+
+Start [`examples/arr-stack/docker-compose.yml`](../examples/arr-stack/docker-compose.yml):
+
+```bash
+export UPSTREAM_TORZNAB_URL="http://dh-waypoint:3333/torznab"
+docker compose -f examples/arr-stack/docker-compose.yml up -d
+```
+
+#### Configuring in `Prowlarr`, `Sonarr`, `Radarr`, `Lidarr`, or `Readarr`:
+1. Open **Settings -> Indexers -> + -> Torznab (Custom)**.
+2. Set **URL** to `http://armiger-torznab-proxy:8097` (instead of pointing directly at `http://bitmagnet:3333/torznab` or `http://dh-waypoint:3333/torznab`).
+3. Every Torznab search query (`?t=search`, `?t=tvsearch`, `?t=movie`, `?t=music`, `?t=book`) is transparently forwarded upstream, batch-scored by `ArmigerUltraPipeline`, stripped of unsafe/honeypot/dead/wrong-language items, and annotated with custom `<torznab:attr>` tags:
+   - `armiger_category` (`movie`, `tv_show`, `music`, `audiobook`, `ebook`, `comic`, `software`, `game`, `xxx`)
+   - `armiger_lang` (`english`, `non_english`, `multi_or_unknown`)
+   - `armiger_viability` (`alive_strong`, `alive_viable`, `marginal`, `dead`)
+   - `armiger_survival_prob` (`0.0000`–`1.0000`)
+
+#### Torznab Proxy Environment Controls
+
+| Variable | Default | Description |
+| :--- | :---: | :--- |
+| `UPSTREAM_TORZNAB_URL` | `http://dh-waypoint:3333/torznab` | Upstream Torznab base URL (`DH-Waypoint`, `Bitmagnet`, or `Prowlarr`). |
+| `ARMIGER_VARIANT` | `int8` | `int8` (`8.3 MB` CPU fast-path, `2.44 ms` p50) or `fp32` (`32.3 MB` GPU/CPU). |
+| `ARMIGER_REJECT_DEAD_SWARMS` | `true` | Drops Torznab items whose `SwarmSurvivalNet` viability tier is `dead`. |
+| `ARMIGER_REQUIRE_ENGLISH_AUDIO` | `false` | When `true`, blocks releases classified as `non_english` audio by `AudioLanguageGuard`. |
+| `ARMIGER_ALLOW_ENGLISH_SUBS` | `true` | When `ARMIGER_REQUIRE_ENGLISH_AUDIO=true`, permits foreign-audio anime/films that carry verified English subtitles (`has_eng_subs`). |
+
+### 2. Stage 2: Wiring Post-Import Webhooks (`Sonarr`, `Radarr`, `Lidarr`, `Readarr`, `qBittorrent`)
+
+`armiger-arr-webhook-receiver` (`port 8098`) exposes dedicated endpoints backed by the adapters in [`armiger_dht_rsi.py`](../armiger_dht_rsi.py):
+
+| Application | Where to Configure in UI | Webhook URL | Underlying Armiger Adapter |
+| :--- | :--- | :--- | :--- |
+| **Sonarr** | `Settings -> Connect -> + -> Webhook` (`On Import`, `On Upgrade`) | `http://armiger-arr-webhook-receiver:8098/webhooks/sonarr` | `SeriesWebhookAdapter` |
+| **Radarr** | `Settings -> Connect -> + -> Webhook` (`On Import`, `On Upgrade`) | `http://armiger-arr-webhook-receiver:8098/webhooks/radarr` | `MovieWebhookAdapter` |
+| **Lidarr** | `Settings -> Connect -> + -> Webhook` (`On Release Import`, `On Upgrade`) | `http://armiger-arr-webhook-receiver:8098/webhooks/lidarr` | `AudioWebhookAdapter` |
+| **Readarr** | `Settings -> Connect -> + -> Webhook` (`On Release Import`, `On Upgrade`) | `http://armiger-arr-webhook-receiver:8098/webhooks/readarr` | `PublicationWebhookAdapter` |
+| **qBittorrent** | `Options -> Downloads -> Run external program` | `POST http://armiger-arr-webhook-receiver:8098/webhooks/qbittorrent` | `QBittorrentAdapter` |
+
+#### `qBittorrent` Completion Command
+
+In `qBittorrent` (`Tools -> Options -> Downloads -> Run external program on torrent completion`), configure:
+
+```bash
+curl -sS -X POST http://armiger-arr-webhook-receiver:8098/webhooks/qbittorrent -H "Content-Type: application/json" -d "{\"name\":\"%N\",\"hash\":\"%I\",\"content_path\":\"%F\",\"size\":%Z,\"progress\":1.0,\"state\":\"uploading\"}"
+```
+
+#### Programmatic Python Usage (`SeriesWebhookAdapter`, `MovieWebhookAdapter`, `QBittorrentAdapter`, `PhysicalGroundTruthVerifier`)
+
+You can also invoke the webhook adapters and `ffprobe` verifier directly in Python via `ArmigerUltraPipeline.ingest_rsi_feedback`:
+
+```python
+from armiger_ultra_pipeline import ArmigerUltraPipeline
+
+pipeline = ArmigerUltraPipeline.from_directory(".", variant="int8")
+
+# 1. Ingest a native Sonarr "Download" (Import) webhook + ffprobe output
+ok, reason, record = pipeline.ingest_rsi_feedback(
+    {
+        "eventType": "Download",
+        "series": {"title": "Cosmos Laundromat", "tvdbId": 310123},
+        "episodes": [{"seasonNumber": 1, "episodeNumber": 1}],
+        "release": {
+            "releaseTitle": "Cosmos.Laundromat.S01E01.1080p.WEB-DL.DDP5.1.H.264-OPEN",
+            "size": 1_450_000_000,
+        },
+        "episodeFile": {
+            "relativePath": "Season 01/Cosmos.Laundromat.S01E01.mkv",
+            "size": 1_450_000_000,
+            "mediaInfo": {
+                "videoCodec": "h264",
+                "audioFormat": "eac3",
+                "audioChannels": 5.1,
+                "audioLanguages": "eng",
+                "subtitles": "eng",
+            },
+        },
+    },
+    adapter="series_webhook",
+)
+assert ok and reason == "accepted_and_queued_with_poisson_jitter"
+print(record.blinded_stem.blinded_hash, record.category, record.lang)
+
+# 2. Ingest a native Radarr "Download" (Import) webhook
+ok, reason, record = pipeline.ingest_rsi_feedback(
+    {
+        "eventType": "Download",
+        "movie": {"title": "Sintel", "year": 2010, "tmdbId": 45745},
+        "release": {
+            "releaseTitle": "Sintel.2010.2160p.UHD.Master.HEVC.FLAC.5.1-OPEN",
+            "size": 24_800_000_000,
+        },
+        "movieFile": {
+            "relativePath": "Sintel (2010)/Sintel.2010.2160p.mkv",
+            "size": 24_800_000_000,
+        },
+    },
+    adapter="movie_webhook",
+)
+assert ok and record.category == "movie"
+```
+
+### 3. `BEP-44` / `BEP-46` Privacy & RSI Participation Modes
+
+All adapters enforce `PhysicalGroundTruthVerifier` (never trusting unverified model predictions) and `TelemetryAnonymizer` (stripping tracker passkeys, local paths, and IP addresses; blinding title stems via post-quantum `HMAC-SHA256` + `SHAKE-256`; applying Laplace differential privacy $\epsilon = 1.0$; and scheduling outbound packets with Poisson timing jitter):
+
+| `ARMIGER_DHT_RSI_MODE` | Behavior |
+| :--- | :--- |
+| `off` | Disables all `BEP-44`/`BEP-46` DHT traffic; calibration and ground-truth verification stay strictly local. |
+| `pull_only` *(Default)* | Verifies and applies `M`-of-`N` hybrid post-quantum (`Ed25519` + `WOTS+-SHAKE256`) signed calibration manifests from the DHT after passing the 500-item golden canary gate; never transmits telemetry. |
+| `anonymous_contribute` | Opts in to transmitting differential-privacy blinded, hybrid post-quantum (`X25519` + `ML-KEM-768` + `ChaCha20-Poly1305`) encrypted ground-truth observations. |