Vela 3.0

.gitattributes

@@ -0,0 +1,38 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/banner.png filter=lfs diff=lfs merge=lfs -text
+assets/family.png filter=lfs diff=lfs merge=lfs -text
+assets/glance.png filter=lfs diff=lfs merge=lfs -text

EVALUATION.md

@@ -0,0 +1,202 @@
+# vela3-flash (9B): evaluation
+
+All numbers were measured through this package, with `system_one`, one request at a time and the shipped thresholds, on an AMD Instinct MI325X (16-17 Oct 2026). The base is vllm-sr/d3-flash at revision `8b35c853b90e777595ec36bacae820fe08ea077a`. Other models' numbers are as reported by their authors.
+
+## 1. Public test sets: unsupported claims and held-out decisions
+
+Vela 2.0 9B values are as published on its model card ([vllm-sr/Vela-2.0-9B](https://huggingface.co/vllm-sr/Vela-2.0-9B), EVALUATION.md; PII with its shipped calibration). We hold no per-row outputs of its release run, so this comparison has no paired differences or confidence intervals; in the README, bold marks a lead of at least 0.02 over the published value.
+
+| benchmark | metric | vela3-flash | best other model | Vela 2.0 9B (published) | n |
+|---|---|---:|---|---:|---:|
+| Hallucination spans, 10,698 examples | example-F1 | 0.897 | LettuceDetect v2 qwen-2b 0.921 | 0.885 | 10698 |
+| RAGTruth | example-F1 | 0.800 | HDM-2 (3B) 0.850 | 0.774 | 2700 |
+| MASSIVE unseen scenarios, intent | accuracy | 0.826 | – | 0.763 | 14911 |
+| MASSIVE unseen scenarios, scenario | accuracy | 0.918 | – | 0.871 | 14911 |
+| Super-NI task 1568 (held out) | accuracy | 0.667 | – | 0.574 | 162 |
+
+MASSIVE: three scenarios never used in our router training (iot, transport, cooking), 52 locales; accuracy on the 14,911 test utterances that match no training text of the model's lineage. The 342 excluded utterances occur verbatim in upstream training mixtures (tasksource MASSIVE / HWU64 rows). Vela 2.0 values are on the full 15,253, so these rows are not bolded.
+
+QASC omitted: its items are in the d3 training mixture. Super-NI 1568: 79 to 90 of its 162 ProPara passages share a 13-gram with other tasks' training rows.
+
+Best other model, same test set and metric only (– where no such number exists): Hallucination spans, 10,698 examples: LettuceDetect v2 qwen-2b 0.921 (reported, KRLabsOrg/lettucedect-v2-qwen-2b card (unified test set, 10,698, example-F1)); RAGTruth: HDM-2 (3B) 0.850 (reported, HalluciNot arXiv 2504.07069 Table 2, example-level F1 on the RAGTruth test set; its training set includes RAGTruth contexts. Next: RAG-HAT 0.839, EMNLP 2024 Industry Table 2). Also reported on RAGTruth: LettuceDetect v2 qwen-2b 0.818 and mmBERT-base 0.743 (their cards).
+
+### Router signals: public router signal suite
+
+[vllm-sr/router-signal-suite](https://huggingface.co/datasets/vllm-sr/router-signal-suite) at `fa08b2a6`, scored with the dataset's own scoring code, one `system_one` call per row with the shipped thresholds. Every test file of the 8 router signals this package was trained on (supervised, as in Vela 2.0). Vela 2.0 9B was run by us through its public release on the same rows; diff = ours minus Vela 2.0 with the 95% paired cluster bootstrap CI (2,000 rounds). Decision-1.0-Route-0.6B is scored from the suite's published predictions (trained on the suite's train split). No-overlap rows: the test rows that share no text (exact or a 13-gram) with this model's training data.
+
+| signal | file | metric | rows | vela3-flash | Vela 2.0 9B | diff [95% CI] | Decision-1.0-Route-0.6B | no-overlap rows: vela3-flash (rows) | no-overlap diff [95% CI] |
+|---|---|---|---:|---:|---:|---|---:|---:|---|
+| Harmful request | test | AUC | 2,230 | 0.958 | 0.957 | +0.001 [-0.005, +0.007] | 0.963 | 0.950 (1,254) | -0.007 [-0.015, -0.000] |
+| Harmful request | test-aegis2 | AUC | 1,749 | 0.944 | 0.935 | +0.009 [+0.003, +0.015] | 0.927 | 0.934 (1,120) | +0.008 [-0.000, +0.017] |
+| Harmful request | test-nemotron-v3 | AUC | 2,000 | 0.922 | 0.913 | +0.009 [+0.001, +0.018] | 0.902 | 0.924 (1,843) | +0.010 [+0.001, +0.020] |
+| Harmful request | test-polyguardprompts | AUC | 2,000 | 0.958 | 0.941 | +0.017 [+0.009, +0.025] | 0.894 | 0.958 (1,955) | +0.016 [+0.008, +0.025] |
+| Harmful request | test-wildguardmix | AUC | 1,696 | 0.963 | 0.957 | +0.006 [+0.000, +0.011] | 0.927 | 0.963 (1,671) | +0.006 [+0.000, +0.011] |
+| Jailbreak or prompt injection | test | AUC | 1,878 | 0.969 | 0.919 | +0.049 [+0.038, +0.062] | 0.991 | 0.970 (944) | +0.068 [+0.051, +0.087] |
+| Personal data in the request | test | AUC | 3,000 | 0.951 | 0.960 | -0.009 [-0.017, -0.001] | 0.994 | 0.953 (2,802) | -0.007 [-0.015, +0.002] |
+| Personal data in the request | test-abcd | AUC | 1,486 | 0.991 | 0.897 | +0.094 [+0.075, +0.112] | 0.999 | 0.989 (1,190) | +0.104 [+0.083, +0.125] |
+| Personal data in the request | test-mapa | AUC | 1,679 | 0.951 | 0.787 | +0.164 [+0.106, +0.187] | 0.984 | 0.951 (1,678) | +0.164 [+0.106, +0.187] |
+| Personal data in the request | test-tab | AUC | 1,461 | 0.987 | 0.977 | +0.010 [+0.001, +0.020] | 0.994 | 0.984 (1,372) | +0.013 [+0.001, +0.026] |
+| Answer not supported by its context | test | AUC | 3,000 | 0.775 | 0.765 | +0.010 [-0.003, +0.022] | 0.791 | 0.737 (1,743) | -0.007 [-0.024, +0.011] |
+| Answer not supported by its context | test-psiloqa | AUC | 1,265 | 0.892 | 0.862 | +0.030 [+0.010, +0.049] | 0.872 | 0.898 (1,146) | +0.021 [+0.002, +0.040] |
+| Answer not supported by its context | test-ragbench | AUC | 1,311 | 0.697 | 0.721 | -0.024 [-0.055, +0.005] | 0.628 | 0.698 (1,223) | -0.023 [-0.056, +0.006] |
+| Answer not supported by its context | test-ragtruth | AUC | 1,528 | 0.880 | 0.865 | +0.014 [-0.006, +0.034] | 0.669 | 0.867 (1,209) | +0.002 [-0.020, +0.023] |
+| Fact-check needed | test | AUC | 800 | 0.856 | 0.809 | +0.047 [+0.035, +0.061] | 0.942 | 0.849 (690) | +0.044 [+0.030, +0.059] |
+| Output modality (text or image) | test | AUC | 3,000 | 0.980 | 0.933 | +0.047 [+0.040, +0.054] | 0.999 | 0.979 (2,916) | +0.049 [+0.042, +0.056] |
+| Output modality (text or image) | test-dolly | specificity at dev threshold | 2,000 | 1.000 | 1.000 | -0.000 (no CI: one-class file) | 0.965 | 0.999 (1,950) | – |
+| Output modality (text or image) | test-realedit | recall at dev threshold | 2,000 | 0.851 | 0.417 | +0.434 (no CI: one-class file) | 1.000 | 0.845 (2,000) | – |
+| Domain (subject area) | test | accuracy | 2,996 | 0.877 | 0.765 | +0.112 [+0.097, +0.126] | 0.863 | 0.878 (2,916) | +0.116 [+0.101, +0.130] |
+| Domain (subject area) | test-exams | accuracy | 1,927 | 0.833 | 0.791 | +0.042 [+0.028, +0.057] | 0.815 | 0.833 (1,907) | +0.042 [+0.027, +0.058] |
+| User feedback on the previous answer | test | accuracy | 2,842 | 0.851 | 0.666 | +0.185 [+0.165, +0.206] | 0.848 | 0.839 (2,295) | +0.208 [+0.187, +0.232] |
+| User feedback on the previous answer | test-sgd | accuracy | 1,998 | 0.959 | 0.807 | +0.152 [+0.135, +0.170] | 0.973 | 0.955 (1,794) | +0.164 [+0.146, +0.182] |
+
+Domain and feedback are also trained on the suite's own train split (with the public router data Vela 2.0 used; the suite's test and hold rows, and anything sharing an exact text or a 13-gram with them, are kept out), as Decision-1.0-Route is, so their test files are in-distribution for both. The domain question has a 15th option, religion, which the suite maps to philosophy. Feedback has NO_FEEDBACK as a trained option. Every other signal answers exactly as before (identity check on dev rows).
+Not shown: hazard and tool need, which have no trained question in this package; the hold files (no Vela 2.0 pairing).
+
+## Hallucination by source (example-F1)
+
+- lettucedetect-acl: n=440 ours 0.970
+- lettucedetect-code-agent: n=2015 ours 0.747
+- lettucedetect-readme: n=641 ours 0.989
+- lettucedetect-tool-output: n=617 ours 0.859
+- lettucedetect-wikipedia: n=1388 ours 0.984
+- psiloqa: n=2897 ours 0.962
+- ragtruth: n=2700 ours 0.800
+
+Long answers are read in windows of at most 1,800 tokens (stride 1,536) when they exceed 2,048 tokens; every window sees the whole context.
+
+## 2. Package checks
+
+- **Non-router questions vs plain d3-flash:** 561 / 561 non-router question rows bitwise identical; answers identical 581 / 581; router rows changed by the decision adapter 92 / 92.
+- **Span answers, shipped runtime vs training runtime:** identical on 6 / 6 requests.
+- **Image adapter added:** text hallucination answers identical to the text-only package on 300 / 300 rows and other span answers on 200 / 200; decisions identical on 50 / 50 requests (10 with images); image span answers identical across runtimes on 40 / 40.
+- **Files:** `SHA256SUMS` covers the package files (adapters, heads, code, configs, licence).
+
+## 3. Zero-shot NER, OOD-7
+
+Strict entity micro-F1 per set, average of the 7 sets.
+
+| mode | avg | 95% CI | AI | Lit | Music | Pol | Sci | Movie | Rest |
+|---|---|---|---|---|---|---|---|---|---|
+| label names in, definitions written by the d3-flash backbone with a grafted Qwen3.5-9B lm_head at inference (default; NER adapter) | **65.44** | 64.54-66.28 | 68.0 | 68.0 | 72.4 | 69.3 | 69.9 | 61.8 | 48.7 |
+| label names only (definitions off; span adapter) | **62.04** | 61.12-63.00 | 61.1 | 63.4 | 64.8 | 65.7 | 69.7 | 60.1 | 49.4 |
+
+Reported on the same 7 sets with label names only: B2NER-7B, standardised label names 69.8 (B2NER, arXiv 2406.11192 Table 3; the best reported entry of this size class), GLiFormer-base 60.40, GLiFormer-large 59.05 (GLiFormer paper). Vela 2.0 9B, names only: 43.5 (published).
+
+The definitions take label names as the only input: the model writes them at inference and caches them per label set; no definition is supplied by the benchmark or by us.
+
+Final NER round (18 Oct; names-only open labels now on the NER adapter): names only 58.9 to 62.0, own definitions 69.6 to 65.4 (before to after; the same test sets, thresholds picked on dev).
+
+
+Label-name overlap: no CrossNER or MIT text is in the training data, but 35 of CrossNER's 41 type names (mostly generic types such as person, organisation, location and country) also occur as label names in the NER training data.
+
+## 4. NER, 26 IE_INSTRUCTIONS datasets
+
+Default mode (definitions written by the model), mean F1 **65.6**. Not all 26 sets are zero-shot.
+
+| ACE_2004 | ACE_2005 | AnatEM | Broad_Tweet_Corpus | CoNLL_2003 | CrossNER_AI | CrossNER_literature | CrossNER_music | CrossNER_politics | CrossNER_science | FabNER | FindVehicle | GENIA_NER |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|
+| 29.5 | 23.9 | 81.8 | 79.4 | 83.1 | 68.0 | 68.0 | 72.4 | 69.3 | 69.9 | 60.8 | 93.9 | 63.1 |
+
+| HarveyNER | MultiNERD | Ontonotes | PolyglotNER | TweetNER7 | WikiANN_en | WikiNeural | bc2gm | bc4chemd | bc5cdr | mit-movie | mit-restaurant | ncbi |
+|---|---|---|---|---|---|---|---|---|---|---|---|---|
+| 49.7 | 76.5 | 60.4 | 51.2 | 40.7 | 67.9 | 86.9 | 73.0 | 77.9 | 84.4 | 61.8 | 48.7 | 63.8 |
+
+## 5. Zero-shot classification (GLiFormer paper suite)
+
+Label names only, no tuning. These questions run on d3-flash with every adapter off. GLiFormer-large numbers as reported in the GLiFormer paper (Table 5).
+
+| dataset | n | vela3-flash | GLiFormer-large |
+|---|---:|---:|---:|
+| CR | 376 | 92.3 | 90.5 |
+| SST-2 | 1,821 | 95.4 | 93.0 |
+| SST-5 | 2,210 | 43.2 | 40.3 |
+| IMDB | 25,000 | 96.0 | 93.9 |
+| 20 Newsgroups | 7,532 | 70.8 | 57.2 |
+| Enron spam | 2,000 | 93.2 | 98.0 |
+| MASSIVE | 2,974 | 83.8 | 70.0 |
+| Banking77 | 3,076 | 92.2 | 70.6 |
+| Financial PhraseBank | 2,264 | 95.8 | 96.8 |
+| AG News | 7,600 | 89.3 | 81.5 |
+| Emotion | 2,000 | 51.6 | 48.1 |
+| CAP SOTU | 23,040 | 57.2 | 49.0 |
+| Rotten Tomatoes | 1,066 | 89.9 | 86.7 |
+| **mean** | | **80.8** | **75.0** |
+
+Reported means over the same 13 sets: GPT-5-mini 79.8, Gemma-4-31B-IT 79.7, GPT-OSS-120B 77.8, GLiFormer-large 75.0, GLiClass Multilang ultra 71.0, GLiNER2 large v1 66.2, GLiNER2.5 64.9.
+
+- The Banking77 copy has 3,076 rows; the paper has 3,080.
+- Financial PhraseBank is the AllAgree subset (2,264 rows); the paper reports 1,129 rows.
+
+## 6. Relation extraction
+
+**Head-conditioned** (gold head given; tail micro-F1):
+
+| set | mode | F1 | 95% CI |
+|---|---|---:|---|
+| CoNLL04 | label names | 40.2 | 36.0-44.3 |
+| CoNLL04 | definitions written by the model (default) | 42.0 | 37.2-46.4 |
+
+
+Vela 2.0 9B: 10.1 on CoNLL04, label names (published).
+
+**End to end, GLiFormer-paper protocol** (entities predicted; strict micro-F1)
+
+| set | mode | strict F1 | P / R |
+|---|---|---:|---|
+| CoNLL04 | per head | 35.4 | 42.2 / 30.5 |
+| CoNLL04 | per (head, relation) | 28.5 | 21.7 / 41.5 |
+| CrossRE (6 domains) | per head | 21.8 | 33.0 / 16.3 |
+| CrossRE | per (head, relation) | 20.9 | 14.1 / 40.5 |
+| DocRED (validation) | per head | 28.8 | 20.5 / 48.5 |
+| FewRel (split 0) | per head | 30.2 | 24.8 / 38.7 |
+| FewRel (split 0) | per (head, relation) | 23.9 | 18.8 / 32.7 |
+
+The README table uses the GLiFormer Table 4 protocol: per head for CoNLL04, DocRED and CrossRE, per (head, relation) for FewRel. Reported (CoNLL04 / DocRED / FewRel / CrossRE / avg): GLiNER-Relex 40.4 / 31.3 / 12.5 / 18.1 / 25.6; Gemma-4-31B-IT 42.3 / 18.0 / 30.2 / 9.8 / 25.1; GPT-5-mini 42.4 / 18.6 / 15.0 / 12.4 / 22.1; GLiFormer-large 35.8 / 12.8 / 24.1 / 12.6 / 21.3; GLiNER2 32.9 / 11.7 / 20.8 / 6.0 / 17.8. FewRel split 0 here has 3,423 sentences, and CrossRE covers all six domains.
+
+**End to end, typed and generic sets** (strict triplet micro-F1)
+
+| CoNLL04 | SciERC | NYT11 | FewRel-0 | avg |
+|---:|---:|---:|---:|---:|
+| 39.1 | 0.0 | 4.1 | 28.3 | 17.9 |
+
+SciERC, NYT11 and FewRel use a generic `entity` type. CoNLL04 is zero-shot; the DocRED, CrossRE and FewRel train splits are in the relation training data (their test sets and FewRel's evaluation relations are held out).
+
+## 7. Evidence
+
+| benchmark | word-F1 | 95% CI |
+|---|---:|---|
+| QASPER evidence (1,141 questions, whole papers; zero-shot) | **44.6** | 42.8-46.3 |
+| ACL-Verbatim evidence (100 rows; in-domain) | **47.5** | 34.4-59.5 |
+
+ACL-Verbatim is in-domain: its silver training split is in the training data.
+
+## 8. Image-grounded hallucination spans
+
+M-HalDetect validation, 786 image descriptions with their images: char-F1 **0.633** [0.605, 0.660], P 0.591 / R 0.680, image adapter at threshold 0.3 (picked on a training-side split, never on validation).
+
+## 9. Latency (AMD Instinct MI325X, batch 1, one verify step per GPU)
+
+| case | 200 tokens | 1K tokens | 3K tokens |
+|---|---:|---:|---:|
+| 4 router decisions, adapter off | 61.8 ms (p90 62.5) | 222.7 ms (p90 236.3) | 398.0 ms (p90 399.0) |
+| 4 router decisions, adapter on | 86.5 ms (p90 87.0) | 267.2 ms (p90 342.6) | 534.8 ms (p90 559.6) |
+| 1 span (10 labels, names only) | 40.0 ms (p90 45.2) | 71.0 ms (p90 73.2) | 207.1 ms (p90 208.7) |
+| 4 decisions + 1 span | 128.4 ms (p90 255.4) | 276.0 ms (p90 278.6) | 747.5 ms (p90 838.4) |
+
+- Label definitions (generation, uncached; measured on the earlier writer configuration, before the 17 Oct change): 378 ms for 4 labels, 501 ms for 10.
+- Multi-passage answer spans (~3K tokens, 100 questions): mean 277 ms, p50 269 ms, p95 332 ms.
+
+## 10. Decisions (Decision Index 0.4.1, 2026-10-21)
+
+| model | public index | full score | full-score rank | note |
+|---|---:|---:|---:|---|
+| Fastino GLiDE V1.2 | 71.99 | 71.52 | 1 |  |
+| StartLux-Decision v1.1 9B | 69.98 | 58.07 | 55 | tied rank |
+| **General decisions = d3-flash** | 57.79 | 54.27 | 71 | this package's base |
+| OneJev1.6-9B | 65.30 | 53.05 | 76 | tied rank |
+| OneJev1.6-0.8B | 48.76 | 29.58 | 155 | tied rank |
+| StartLux-Decision v1.1 0.8B | 53.79 | 28.88 | 158 | tied rank |
+| GLiClass v4 Edge (0.4B) | 47.49 | – | – | own card, public part; not on the board |
+| GLiClass v4 9B | 55.56 | – | – | own card, public part; not on the board |
+
+General decisions are the base model's own answers, bit for bit; no Vela package was run on the board. Full score (the board's ranking): 60% private same-skill tests and 40% private new-domain tasks; public index: the 37 public benchmarks, chance-corrected. All values reported on the Decision Index 0.4.1 board (2026-10-21; multimodalart/jev-decision-index, data generated 2026-10-22) unless noted; tied ranks share a number. On the board's Full score, d3-flash scores 54.27 (rank 71, tied).

LICENSE

@@ -0,0 +1,201 @@
+                                 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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

README.md

@@ -0,0 +1,280 @@
+---
+license: apache-2.0
+pipeline_tag: zero-shot-classification
+library_name: transformers
+base_model:
+- vllm-sr/d3-flash
+base_model_relation: adapter
+tags:
+- decision-model
+- system-one
+- semantic-router
+- vela
+- zero-shot-classification
+- token-classification
+- named-entity-recognition
+- relation-extraction
+- pii-detection
+- hallucination-detection
+- content-safety
+- multimodal
+---
+
+![vela3-flash](assets/banner.png)
+
+<p align="center"><b>Name it. Vela finds it.</b><br>
+<sub>vLLM Semantic Router × KR Labs · Vela 3.0 family · <b>vela3-flash</b> · 9B · base <code>d3-flash</code> · Apache-2.0</sub></p>
+
+<p align="center">
+<a href="#what-it-does">What it does</a> ·
+<a href="#quick-start">Quick start</a> ·
+<a href="#evaluation">Evaluation</a> ·
+<a href="#the-family">The family</a> ·
+<a href="https://huggingface.co/collections/vllm-sr/vela-30-6ad1c430eb1718eb4754edcd">📡 Collection</a>
+</p>
+
+---
+
+**vela3-flash** is the 9B member of the Vela 3.0 family, built on [d3-flash](https://huggingface.co/vllm-sr/d3-flash). In one `system_one` call it answers routing and general decisions and finds the exact spans you name (entities, relations, personal data, unsupported claims, evidence), with probabilities and character offsets and no generated text.
+
+| | |
+| --- | --- |
+| **Parameters** | 8.39B with vision encoder (base) + 3615 MB of adapters and heads |
+| **Base** | [vllm-sr/d3-flash](https://huggingface.co/vllm-sr/d3-flash) at revision `8b35c853`, unchanged |
+| **Inputs** | Text or JSON, plus images |
+| **Answers** | Choice · Yes / No · Score · Span |
+| **Licence** | Apache-2.0 |
+
+## At a glance
+
+| | |
+| --- | --- |
+| **What it is** | An 8.4B decision-and-extraction model for LLM routing and guardrails. It runs [vllm-sr/d3-flash](https://huggingface.co/vllm-sr/d3-flash), a large d3 decision model, unchanged, and adds the exact spans you name: entities, relations, personal data, unsupported claims and evidence. |
+| **How it was trained** | d3-flash stays frozen, so every ordinary decision is d3-flash's own answer, bit for bit. Vela adds small gated LoRA adapters on top, one per job: spans (unsupported claims, personal data, evidence), entities, relations, router signals and image hallucination spans. Each adapter switches on only for its own questions. Router signals are trained supervised, as in Vela 2.0, on the public router datasets Vela 2.0 used (for example AEGIS 2.0, PolyGuardMix and Nemotron-Safety-Guard v3 for safety, Global-MMLU for domain, WildFeedback for feedback, DiffusionDB for modality, MASSIVE for intents); domain and feedback also on the public router signal suite's train split. Other training data: public NER, relation, hallucination, evidence and PII datasets, plus web and document text labelled by a large teacher model. No test split and no Decision Index item is trained on; some router-signal-suite test rows also occur in public training sources, so the router table also reports the rows without that overlap. |
+| **What it is good at** | Zero-shot classification; zero-shot relations; zero-shot NER; router signals above Vela 2.0 9B on 5 of 8 signals of the public router signal suite. Pick it for high-accuracy routing. |
+| **How we measure it** | Public test sets only, run through this package one request at a time with the shipped thresholds: CoNLL04, CoNLL04 · DocRED · FewRel · CrossRE (avg), OOD-7 (CrossNER + MIT), RAGTruth, Super-NI task 1568, the 13-set GLiFormer classification suite, the Decision Index 0.4.1, the LettuceDetect v2 test set, the public router signal suite. Other models' numbers are as their authors report them on the same test set and metric, or scored by us on the same rows where a table says so. |
+
+## Why use it
+
+- **Zero-shot classification:** 80.8 on the 13-set GLiFormer classification suite ✦, beats Gemma-4-31B-IT (31B, 4× larger): 79.69 (reported, GLiFormer paper Tab 5).
+- **Zero-shot relations:** 27.5 on CoNLL04 · DocRED · FewRel · CrossRE (avg) ✦, beats Gemma-4-31B-IT, prompted (31B, 4× larger): 25.08 (reported, GLiFormer paper Tab 4).
+- **Zero-shot NER:** 62.0 on OOD-7 (CrossNER + MIT), beats UniNER-13B (13B, 2× larger): 55.6 (reported, UniNER Tab 3).
+- **Decisions, bit for bit:** every non-router question is answered by `d3-flash@8b35c853` itself (561 of 561 rows identical in our check).
+
+![Results at a glance](assets/glance.png)
+<sub>vela3-flash (9B) against reported numbers. Accent = vela3-flash; grey = other models (reported).</sub>
+
+## What it does
+
+| Capability | Ask (one question of a `system_one` call) | Get |
+| --- | --- | --- |
+| **Decisions** | `{"type": "choice", "instructions": "Which topic?", "criteria": {"billing": None, "tech": None}}` (also `noul`, `score`) | a probability per option, from d3-flash itself |
+| **Router signals** | a built-in router question id from `router_questions.json` | the signal's answer from the gated decision adapter |
+| **Named entities** | `{"type": "span", "criteria": ["drug", "dosage"]}` | spans with label, offsets and score |
+| **Relations** | `{"type": "span", "instructions": "Which spans are the founder of Apple?", "criteria": {"founder": None}}` | the related spans |
+| **Personal data** | `{"type": "span", "criteria": ["PERSON", "EMAIL_ADDRESS"]}` | spans of the 17 trained PII types, any subset |
+| **Unsupported claims** | state `{"context": ..., "answer": ...}` and `{"type": "span", "criteria": {"unsupported": None}}` | the words of the answer the context does not support |
+| **Evidence** | `{"type": "span", "criteria": ["evidence"]}` | the sentences that support the answer |
+| **Image-grounded claims** | the unsupported-claims question with `images=["photo.jpg"]` | the words the image does not support |
+
+## Quick start
+
+```python
+# pip install "transformers==5.17.0" torch torchvision pillow opencv-python-headless safetensors accelerate
+from transformers import AutoModel
+
+m = AutoModel.from_pretrained("vllm-sr/vela3-flash", trust_remote_code=True)  # downloads d3-flash at the pinned revision
+
+# Name any labels; the spans come back with offsets and scores.
+r = m.system_one(
+    state="Geoffrey Hinton presented capsule networks at NeurIPS in Montreal.",
+    questions={"ents": {"type": "span", "criteria": ["researcher", "algorithm", "conference", "location"]}})
+# researcher "Geoffrey Hinton", algorithm "capsule networks", conference "NeurIPS", location "Montreal"
+
+# Unsupported claims in an answer, against a context or an image.
+r = m.system_one(
+    state={"context": "The Eiffel Tower is 330 metres tall and was completed in 1889.",
+           "answer": "The Eiffel Tower is 330 metres tall and was completed in 1925 by Gustave Eiffel's son."},
+    questions={"halu": {"type": "span", "criteria": {"unsupported": None}}})
+# flags "1925 by Gustave Eiffel's son"; add images=["photo.jpg"] to check an answer against a photo
+
+# PII, relations and evidence use the same call.
+r = m.system_one(
+    state="Steve Jobs founded Apple in Cupertino together with Steve Wozniak.",
+    questions={"pii": {"type": "span", "criteria": ["PERSON"]},
+               "rel": {"type": "span", "instructions": "Which spans are the founder of Apple?", "criteria": {"founder": None}}})
+```
+
+## Evaluation
+
+All numbers on public test sets, measured through this package with `system_one`, one request at a time and the shipped thresholds. Other models' numbers are as reported by their authors (or scored in the same harness where marked). Full per-set tables: [EVALUATION.md](EVALUATION.md).
+
+<details open><summary><b>Named entities</b></summary>
+
+| Benchmark | vela3-flash | Best other model (reported) | Vela 2.0 9B | Size-class best (5-10B, reported) |
+|---|---:|---|---:|---|
+| OOD-7, label names only (F1) | 62.0 | B2NER-20B 72.1 (standardised label names; B2NER Tab 3) | 43.5 | B2NER-7B, standardised label names 69.8 (B2NER, Table 3) |
+| OOD-7, label names in, own definitions (default) | 65.4 | same | same | same |
+| NER, 26 datasets of the GLiFormer paper (default mode; not all zero-shot) | 65.6 | – | – | – |
+
+Label names are the only input; the model writes its own definitions at inference (the d3-flash backbone with a grafted Qwen3.5-9B lm_head) and caches them per label set. Training holds no CrossNER or MIT text, though many generic CrossNER type names occur as training labels.
+
+</details>
+
+<details open><summary><b>Relations</b></summary>
+
+| Benchmark | vela3-flash | Best other model (reported) | Vela 2.0 9B | Size-class best (5-10B, reported) |
+|---|---:|---|---:|---|
+| CoNLL04, head entity given, label names (F1) | **40.2** | GLiFormer-base 8.6 (same harness, Vela 2.0 card) | 10.1 | – |
+| CoNLL04, head entity given, own definitions (default) | **42.0** | same | same | – |
+| End to end, GLiFormer Table 4 protocol, avg of 4 (strict F1) | **27.5** | Qwen3.5-9B, prompted 25.7 (GLiFormer paper Tab 4) | – | Qwen3.5-9B, prompted 25.7 |
+| End to end: CoNLL04 · DocRED · FewRel · CrossRE (CoNLL04 zero-shot, others in-domain) | 35.4 · 28.8 · 23.9 · 21.8 | GPT-5-mini 42.4 · GLiNER-Relex 31.3 · Qwen3.5-9B 71.6 · GLiNER-Relex 18.1 (GLiFormer paper Tab 4) | – | – |
+
+CrossRE 21.8 (in-domain) is above every model reported in the GLiFormer paper (best: GLiNER-Relex 18.1).
+
+</details>
+
+<details open><summary><b>Evidence</b></summary>
+
+| Benchmark | vela3-flash | Best other model (reported) | Vela 2.0 9B | Size-class best (5-10B, reported) |
+|---|---:|---|---:|---|
+| QASPER, word-F1 (zero-shot) | 44.6 | – | – | – |
+| ACL-Verbatim, word-F1 (in-domain) | 47.5 | ACL-Verbatim ModernBERT 53.4 (in-domain, evidence only; Vela 2.0 card) | 24.5 | – |
+
+ACL-Verbatim is in-domain: its silver training split is in the training data.
+
+</details>
+
+<details open><summary><b>Unsupported claims (hallucination spans)</b></summary>
+
+| Benchmark | vela3-flash | Best other model (reported) | Vela 2.0 9B | Size-class best (5-10B, reported) |
+|---|---:|---|---:|---|
+| LettuceDetect v2 test set, 10,698 answers (example-F1) | 0.897 | LettuceDetect v2 qwen-2b 0.921 (its card) | 0.885 | – |
+| RAGTruth (example-F1) | 0.800 | HDM-2 (3B) 0.850 (HalluciNot Tab 2) | 0.774 | RAG-HAT (8B) 0.839 (reported, RAG-HAT Tab 2) |
+| M-HalDetect validation, image-grounded (char-F1) | 0.633 | – | no image path | – |
+
+</details>
+
+<details open><summary><b>Zero-shot classification</b></summary>
+
+| Benchmark | vela3-flash | Best other model (reported) | Vela 2.0 9B | Size-class best (5-10B, reported) |
+|---|---:|---|---:|---|
+| GLiFormer suite, 13 sets, label names only (mean macro-F1) | **80.8** | GPT-5-mini 79.8 (GLiFormer paper Tab 5) | – | Gemma-4-E4B (8.0B) 74.1 |
+
+These questions run on d3-flash with every adapter off.
+
+</details>
+
+<details open><summary><b>Router signals</b> (public router signal suite; above Vela 2.0 9B on 5 of 8)</summary>
+
+| Signal (metric, test rows) | vela3-flash | Vela 2.0 9B, same rows | Decision-1.0-Route-0.6B, same rows | Rows sharing no text with training: vela3-flash / Vela 2.0 9B |
+|---|---:|---:|---:|---|
+| Harmful request (AUC, 2,230) | 0.958 | 0.957 | 0.963 | 0.950 / **0.958** (1,254) |
+| Jailbreak or prompt injection (AUC, 1,878) | **0.969** | 0.919 | 0.991 | **0.970** / 0.902 (944) |
+| Personal data in the request (AUC, 3,000) | 0.951 | **0.960** | 0.994 | 0.953 / 0.960 (2,802) |
+| Answer not supported by its context (AUC, 3,000) | 0.775 | 0.765 | 0.791 | 0.737 / 0.744 (1,743) |
+| Fact-check needed (AUC, 800) | **0.856** | 0.809 | 0.942 | **0.849** / 0.805 (690) |
+| Output modality (text or image) (AUC, 3,000) | **0.980** | 0.933 | 0.999 | **0.979** / 0.930 (2,916) |
+| Domain (subject area) (accuracy, 2,996) | **0.877** | 0.765 | 0.863 | **0.878** / 0.763 (2,916) |
+| User feedback on the previous answer (accuracy, 2,842) | **0.851** | 0.666 | 0.848 | **0.839** / 0.631 (2,295) |
+
+[vllm-sr/router-signal-suite](https://huggingface.co/datasets/vllm-sr/router-signal-suite) (public), the `test` file of each signal, scored with the dataset's own scoring code. Each signal is a router question this package was trained on (supervised, as in Vela 2.0), asked one request at a time with the shipped thresholds.
+
+Vela 2.0 9B was run by us through its public release on the same rows. Decision-1.0-Route-0.6B is scored from the suite's published predictions; it was trained on the suite's own train split, so these test files are in-distribution for it.
+
+Bold: the paired 95% bootstrap CI against Vela 2.0 excludes a tie. The last column drops the test rows that share text (exact or a 13-gram) with this model's training data. Safety and jailbreak are scored on the rows whose text the suite publishes (2,230 of 3,003 and 1,878 of 3,000).
+
+Domain and feedback are also trained on the suite's own train split (with the public router data Vela 2.0 used; the suite's test and hold rows, and anything sharing an exact text or a 13-gram with them, are kept out), as Decision-1.0-Route is, so their test files are in-distribution for both. The domain question has a 15th option, religion, which the suite maps to philosophy. Feedback has NO_FEEDBACK as a trained option.
+
+</details>
+
+<details open><summary><b>Decisions</b> (general decisions are the base model's, bit for bit)</summary>
+
+| Decision Index 0.4.1 (2026-10-21) | Public index | Full score (board rank) |
+|---|---:|---:|
+| Fastino GLiDE V1.2 | 71.99 | 71.52 (1) |
+| StartLux-Decision v1.1 9B (tied rank) | 69.98 | 58.07 (55) |
+| **General decisions = d3-flash** (this package's base) | 57.79 | 54.27 (71) |
+| OneJev1.6-9B (tied rank) | 65.30 | 53.05 (76) |
+| OneJev1.6-0.8B (tied rank) | 48.76 | 29.58 (155) |
+| StartLux-Decision v1.1 0.8B (tied rank) | 53.79 | 28.88 (158) |
+| GLiClass v4 Edge (0.4B) (own card, public part; not on the board) | 47.49 | – |
+| GLiClass v4 9B (own card, public part; not on the board) | 55.56 | – |
+
+General decisions are the base model's own answers, bit for bit; no Vela package was run on the board. Full score (the board's ranking): 60% private same-skill tests and 40% private new-domain tasks; public index: the 37 public benchmarks, chance-corrected. All values reported on the Decision Index 0.4.1 board (2026-10-21; multimodalart/jev-decision-index, data generated 2026-10-22) unless noted; tied ranks share a number. On the board's Full score, d3-flash scores 54.27 (rank 71, tied).
+
+| Benchmark | vela3-flash | Best other model (reported) | Vela 2.0 9B | Size-class best (5-10B, reported) |
+|---|---:|---|---:|---|
+| Super-NI task 1568, held out (accuracy) | 0.667 | – | 0.574 | – |
+| MASSIVE, three unseen scenarios: intent / scenario (accuracy; 14,911 decontaminated rows) | 0.826 / 0.918 | – | 0.763 / 0.871 (full set) | – |
+
+MASSIVE: three scenarios never used in our router training (iot, transport, cooking), 52 locales; accuracy on the 14,911 test utterances that match no training text of the model's lineage. The 342 excluded utterances occur verbatim in upstream training mixtures (tasksource MASSIVE / HWU64 rows). Vela 2.0 values are on the full 15,253, so these rows are not bolded. Super-NI 1568: 79 to 90 of its 162 ProPara passages share a 13-gram with other tasks' training rows.
+
+</details>
+
+<details><summary><b>Latency</b></summary>
+
+| Median, one request, AMD Instinct MI325X (one verify step per GPU) | 200 tokens | 1K tokens | 3K tokens |
+|---|---:|---:|---:|
+| 4 router decisions | 86 ms | 267 ms | 535 ms |
+| 1 span question | 40 ms | 71 ms | 207 ms |
+| 4 decisions + 1 span | 128 ms | 276 ms | 748 ms |
+
+Span questions with label names only. A new label set adds a one-off definition-writing step; its latency on the current writer is not measured yet.
+
+</details>
+
+### Benchmarks
+
+- **OOD-7** (CrossNER AI, literature, music, politics, science; MIT movie, restaurant): find the entities of the named types in text from domains the model was not trained on (strict entity F1).
+- **NER, 26 datasets of the GLiFormer paper** (IE_INSTRUCTIONS): entities of named types across 26 public NER sets, not all zero-shot (strict entity F1).
+- **CoNLL04, head entity given:** given one entity of a sentence, find the entities it is related to by the named relation (F1 over those tail entities).
+- **Relations end to end, GLiFormer Table 4 protocol** (CoNLL04, DocRED, FewRel, CrossRE): find the entity pairs and their relation from raw text (strict triplet F1).
+- **QASPER:** find the sentences of a research paper that answer a question about it (word-F1).
+- **ACL-Verbatim** ([KRLabsOrg/acl-verbatim-spans](https://huggingface.co/datasets/KRLabsOrg/acl-verbatim-spans)): find the passage of an ACL paper that supports an answer (word-F1).
+- **M-HalDetect** (validation): which words of an image description the image does not support (char-F1).
+- **LettuceDetect v2 test set** (10,698 answers, as in the LettuceDetect v2 paper and card): does an answer contain claims its context does not support (example-F1: the answer is flagged or not).
+- **RAGTruth:** does a retrieval-augmented answer contain claims its retrieved context does not support (example-F1).
+- **MASSIVE, three unseen scenarios** (iot, transport, cooking; 52 languages): pick the intent and the scenario of a user command the model never saw in training (accuracy).
+- **Super-NI task 1568** (ProPara): answer a multiple-choice question about how a process changes an entity (accuracy).
+- **Zero-shot classification, 13 sets** (the GLiFormer paper's suite: SST-2, IMDB, AG News, Banking77, and more): pick the label of a text from label names only (mean macro-F1).
+- **Decision Index 0.4.1** ([board](https://huggingface.co/spaces/multimodalart/jev-decision-index), 2026-10-21): 37 public decision benchmarks plus private tests; the Full score ranks on the private same-skill and new-domain tests (chance-corrected skill, 0 = guessing).
+- **Router signal suite** ([vllm-sr/router-signal-suite](https://huggingface.co/datasets/vllm-sr/router-signal-suite)): the vLLM Semantic Router's public test of its request signals (harmful requests, jailbreaks, personal data, unsupported answers, fact-check need, modality, domain, feedback); each label comes from public corpora (AUC or accuracy).
+
+## The family
+
+![The Vela 3.0 family](assets/family.png)
+
+| Model | Size | Base | Best for |
+|---|---|---|---|
+| [vela3-fast](https://huggingface.co/vllm-sr/vela3-fast) | 0.4B | UltraBERT-380M encoder | the default router; fastest: decisions + spans in one ~13 ms encoder pass, English, 32K |
+| [vela3-fast-vision](https://huggingface.co/vllm-sr/vela3-fast-vision) | 0.3B | UltraVBERT encoder | image decisions, image-grounded hallucination spans, region pointing (preview) |
+| [vela3-lite](https://huggingface.co/vllm-sr/vela3-lite) | 0.8B | d3-lite | small GPUs, low latency |
+| [vela3-mini](https://huggingface.co/vllm-sr/vela3-mini) | 4B | d3-mini | balanced accuracy and speed |
+| [vela3-flash](https://huggingface.co/vllm-sr/vela3-flash) | 9B | d3-flash | high-accuracy routing |
+| [vela3-turbo](https://huggingface.co/vllm-sr/vela3-turbo) | 27B | d3-turbo | the reference model |
+
+## How it works
+
+- **Frozen base.** `d3-flash@8b35c853` runs unchanged; ordinary questions are its own answers.
+- **Gated LoRA adapters.** Each switches on only for its own questions, and every answer names the one it used (`head_reason`): decision (router signals), NER (entity labels with definitions), relation, image (hallucination spans with images), span (evidence, PII, unsupported claims, toxic spans, names-only labels).
+- **Spans as decisions.** The labels are presented as options; a span head scores every word against every label, and agreeing neighbours form a span with character offsets.
+- **Self-written definitions.** Before reading, the model (the d3-flash backbone with a grafted Qwen3.5-9B lm_head) writes a one-line definition for each undescribed label, cached per label set: OOD-7 goes from 62.0 (names) to 65.4.
+- **Specification.** Adds 3615 MB of adapters and heads (including the 1.9 GB lm_head that writes definitions); image threshold 0.3; text or JSON state, images and video for decisions, images for hallucination spans. Full evaluation: [EVALUATION.md](EVALUATION.md).
+
+## Trade-offs
+
+- **Router signals below Vela 2.0 9B on the public suite:** personal data 0.951 against 0.960 (same rows).
+- **Unsupported claims:** hallucination spans 0.897 against 0.921 for LettuceDetect v2 qwen-2b, RAGTruth 0.800 against 0.850 for HDM-2 (3B) (reported).
+- **General decisions are d3-flash's:** below StartLux-Decision v1.1 9B (full score 58.07 vs 54.27) on the Decision Index 0.4.1.
+
+## Citation
+
+```bibtex
+@misc{vela3_flash,
+  title        = {vela3-flash (Vela 3.0, 9B): zero-shot extraction and router signals on Decision 3.0},
+  author       = {{KR Labs} and {vLLM Semantic Router}},
+  year         = {2026},
+  howpublished = {\url{https://huggingface.co/vllm-sr/vela3-flash}}
+}
+```

SHA256SUMS

@@ -0,0 +1,22 @@
+c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4  LICENSE
+b91b6bc80639b2203cf9fc69b99e6c917e2fc5c888e4f96dec979337f29f70cd  calibration.json
+089b20e6da48568c939165a97598c199ee2329f700fae59a14f65c27e7bd68d0  config.json
+713622285c348d885ffdd9b6199cd8540f6435d172b2048a04239a7ee42cbb4f  decision_df_lora.safetensors
+369df81e576fd54ef3c98c5f48fca88892f2bd38c72b159c91348eb410e72b5e  decision_lora.safetensors
+e6ec4981046337e0e7e1bf9696ce15d281bdd691188f1adb33e6a8d53466ff0d  image_halu_head.safetensors
+64d5b39a3997b0263d56e737878e3c4937177fefc30f83d5649880a88433455b  image_halu_lora.safetensors
+4cd699d86c9d41a7947e19ae944541d9d552fc68e94b7c11d40b9b67b1afe62c  label_definitions.json
+3d43ed7f6b0af94195d6ea687a59141384a4fba5a3756016aade8c9c0c208662  labeldef_lm_head.safetensors
+2842509459d9e56e0576bc81b1262a6a0d0b437ac5d23c112e5cb22f2e76ea48  modeling_vela3.py
+cc710bdeb492c51564600ff09b645bce2b716d1fff76e810249b0926dd2e49fe  ner_head.safetensors
+3272c03b55df4927aa733a2b5dc45af1b4474cf2034924b6a8c45a084513b9a7  ner_lora.safetensors
+8bf595b1d23ea1f6d7dc6f751322dad6ed81b86bf2f0c9669d169aec24013cc2  relation_head.safetensors
+180701270272b6ad94e1048027e026c15cddab85da9e7a32c7491ed94ad5e87f  relation_lora.safetensors
+8ed409d39cf03e49ccc5c5868643d73b72aa078497c848d214a370dd317fe3ec  router_questions.json
+d2c5f2f446cf12d2f8a24dbf634452477088523b0973e1e07df244c851421efb  span_decode_v2.py
+e5e74fe176bfd580f86448a152c7a8e9d278645baaf155e5f2f0ee3b766c8a61  span_head.safetensors
+d1c684f81bd9f4d9d2c749120162f26482a9e05984ca8865652a5ec3c18a109d  span_lora.safetensors
+eb69e58c18593527a0eb0bade7bc05eec315f3039fe92e1c500ba9c5f0a36d31  vela3_adapters.py
+9c14b2d82a95f33eb2c094f301a2f33450205b67e5cdd3cf6082e1fd827847ae  vela3_config.json
+b7fcefdd1a0b3e8ac22ac12338c72e76925688a989b5af6c70a104fa70122a39  vela3_labeldef.py
+97d2448765a7ee5411dff44c601c3a073fdad9a9921f9818bac4135916081c20  vela3_span.py

calibration.json

@@ -0,0 +1,1823 @@
+{
+ "span_pick": {
+  "rule": "diag04b-fam: forced checkpoint (every candidate is read)",
+  "all": {
+   "ckpt-005000/final": {
+    "threshold": 0.6,
+    "thr_f1": 0.6900049075740226,
+    "eval_f1": 0.6933728981206726
+   }
+  },
+  "choice": {
+   "ckpt": "ckpt-005000",
+   "head": "final",
+   "threshold_defs": 0.6,
+   "threshold_names": 0.6
+  },
+  "names_at_choice": {
+   "threshold": 0.6,
+   "thr_f1": 0.6824146981627297,
+   "eval_f1": 0.6887417218543046
+  }
+ },
+ "evidence_pick": {
+  "setting": {
+   "ckpt": "ckpt-005000",
+   "head": "final",
+   "threshold_defs": 0.6,
+   "threshold_names": 0.6
+  },
+  "choice": {
+   "decode": "sent",
+   "gap": 0,
+   "minc": 0,
+   "threshold": 0.5,
+   "thr": {
+    "acl_val": 0.686591771382674,
+    "vsdev": 0.748391122898709
+   },
+   "objective": 0.7174914471406915
+  },
+  "eval_at_choice": {
+   "acl_val": 0.6625224785205248,
+   "vsdev": 0.7029013539651837
+  },
+  "eval_plain_at_its_best_threshold": {
+   "threshold": 0.5,
+   "acl_val": 0.6604015001103022,
+   "vsdev": 0.7053062276490866
+  },
+  "eval_plain_06": {
+   "acl_val": 0.6556993302555433,
+   "vsdev": 0.6937891737891738
+  },
+  "rule": "max mean thr-half word F1 over acl_val + vsdev; ties -> higher threshold",
+  "grid": {
+   "plain/g0/m0/t0.05": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.4455486888257892,
+     "vsdev": 0.5165089743867322
+    },
+    "objective": 0.48102883160626064
+   },
+   "plain/g0/m0/t0.1": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.4915471131043227,
+     "vsdev": 0.5666634670762142
+    },
+    "objective": 0.5291052900902684
+   },
+   "plain/g0/m0/t0.15": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.5269644228308165,
+     "vsdev": 0.6076146076146076
+    },
+    "objective": 0.567289515222712
+   },
+   "plain/g0/m0/t0.2": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5568345621452366,
+     "vsdev": 0.6386198547215496
+    },
+    "objective": 0.5977272084333931
+   },
+   "plain/g0/m0/t0.25": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.5847629588636782,
+     "vsdev": 0.6626478223247765
+    },
+    "objective": 0.6237053905942274
+   },
+   "plain/g0/m0/t0.3": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.6102066399135913,
+     "vsdev": 0.6832471029620888
+    },
+    "objective": 0.64672687143784
+   },
+   "plain/g0/m0/t0.35": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6340604733428788,
+     "vsdev": 0.6998637904273179
+    },
+    "objective": 0.6669621318850985
+   },
+   "plain/g0/m0/t0.4": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.6521026959032045,
+     "vsdev": 0.7112881095010207
+    },
+    "objective": 0.6816954027021126
+   },
+   "plain/g0/m0/t0.45": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.6713312609021898,
+     "vsdev": 0.7281083006768791
+    },
+    "objective": 0.6997197807895345
+   },
+   "plain/g0/m0/t0.5": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.6838200473559589,
+     "vsdev": 0.7425260718424103
+    },
+    "objective": 0.7131730595991845
+   },
+   "plain/g0/m0/t0.55": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6852213837621601,
+     "vsdev": 0.7309627499894296
+    },
+    "objective": 0.7080920668757948
+   },
+   "plain/g0/m0/t0.6": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6740108078963815,
+     "vsdev": 0.7142726774958934
+    },
+    "objective": 0.6941417426961374
+   },
+   "plain/g0/m0/t0.65": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.653026876347762,
+     "vsdev": 0.6757356202868549
+    },
+    "objective": 0.6643812483173084
+   },
+   "plain/g0/m0/t0.7": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.6177944156721459,
+     "vsdev": 0.6202518139137858
+    },
+    "objective": 0.6190231147929659
+   },
+   "plain/g0/m0/t0.75": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5699812100714017,
+     "vsdev": 0.5684978345110554
+    },
+    "objective": 0.5692395222912285
+   },
+   "plain/g0/m0/t0.8": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.5118649517684888,
+     "vsdev": 0.5101052886360885
+    },
+    "objective": 0.5109851202022886
+   },
+   "plain/g0/m0/t0.85": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.419776216497528,
+     "vsdev": 0.44228308164832353
+    },
+    "objective": 0.43102964907292574
+   },
+   "plain/g0/m0/t0.9": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.294593572778828,
+     "vsdev": 0.3488052732765724
+    },
+    "objective": 0.32169942302770016
+   },
+   "plain/g0/m0/t0.95": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.11567681007345225,
+     "vsdev": 0.24919567124890318
+    },
+    "objective": 0.18243624066117772
+   },
+   "plain/g0/m10/t0.05": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.45528455284552843,
+     "vsdev": 0.5253647141786769
+    },
+    "objective": 0.49032463351210265
+   },
+   "plain/g0/m10/t0.1": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.501062794970638,
+     "vsdev": 0.575218865071817
+    },
+    "objective": 0.5381408300212275
+   },
+   "plain/g0/m10/t0.15": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.5368781375378796,
+     "vsdev": 0.6147868094938038
+    },
+    "objective": 0.5758324735158418
+   },
+   "plain/g0/m10/t0.2": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5655963948739614,
+     "vsdev": 0.6456267409470752
+    },
+    "objective": 0.6056115679105183
+   },
+   "plain/g0/m10/t0.25": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.593926963708066,
+     "vsdev": 0.6691599707815923
+    },
+    "objective": 0.6315434672448291
+   },
+   "plain/g0/m10/t0.3": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.6185366324527816,
+     "vsdev": 0.6894670711899727
+    },
+    "objective": 0.6540018518213772
+   },
+   "plain/g0/m10/t0.35": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6409529698718609,
+     "vsdev": 0.7042325835124987
+    },
+    "objective": 0.6725927766921798
+   },
+   "plain/g0/m10/t0.4": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.6580076197153215,
+     "vsdev": 0.7144070387607432
+    },
+    "objective": 0.6862073292380324
+   },
+   "plain/g0/m10/t0.45": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.6770430331527886,
+     "vsdev": 0.733413052143349
+    },
+    "objective": 0.7052280426480688
+   },
+   "plain/g0/m10/t0.5": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.6873314787074684,
+     "vsdev": 0.7441127825470585
+    },
+    "objective": 0.7157221306272634
+   },
+   "plain/g0/m10/t0.55": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6865654407944114,
+     "vsdev": 0.7285542375795083
+    },
+    "objective": 0.7075598391869599
+   },
+   "plain/g0/m10/t0.6": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6739516459500069,
+     "vsdev": 0.7098560354374308
+    },
+    "objective": 0.6919038406937188
+   },
+   "plain/g0/m10/t0.65": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.6490672485829098,
+     "vsdev": 0.6675977653631284
+    },
+    "objective": 0.658332506973019
+   },
+   "plain/g0/m10/t0.7": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.611544151115157,
+     "vsdev": 0.613915857605178
+    },
+    "objective": 0.6127300043601676
+   },
+   "plain/g0/m10/t0.75": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5668986384266262,
+     "vsdev": 0.5615791896869244
+    },
+    "objective": 0.5642389140567754
+   },
+   "plain/g0/m10/t0.8": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.5054646135911012,
+     "vsdev": 0.5065953437481003
+    },
+    "objective": 0.5060299786696008
+   },
+   "plain/g0/m10/t0.85": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.4129923113133532,
+     "vsdev": 0.4347210604208223
+    },
+    "objective": 0.42385668586708775
+   },
+   "plain/g0/m10/t0.9": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.2876082662209391,
+     "vsdev": 0.34256961676316516
+    },
+    "objective": 0.31508894149205213
+   },
+   "plain/g0/m10/t0.95": {
+    "decode": "plain",
+    "gap": 0,
+    "minc": 10,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.10881058196600459,
+     "vsdev": 0.2470166190789955
+    },
+    "objective": 0.17791360052250005
+   },
+   "gap20/g20/m10/t0.05": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.43264858004764223,
+     "vsdev": 0.503677787847493
+    },
+    "objective": 0.4681631839475676
+   },
+   "gap20/g20/m10/t0.1": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.4788270462633452,
+     "vsdev": 0.5538223721191681
+    },
+    "objective": 0.5163247091912566
+   },
+   "gap20/g20/m10/t0.15": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.5151243558144746,
+     "vsdev": 0.596678077849626
+    },
+    "objective": 0.5559012168320503
+   },
+   "gap20/g20/m10/t0.2": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5464588225004542,
+     "vsdev": 0.6299391480730223
+    },
+    "objective": 0.5881989852867382
+   },
+   "gap20/g20/m10/t0.25": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.5752146673107286,
+     "vsdev": 0.6563068181818182
+    },
+    "objective": 0.6157607427462735
+   },
+   "gap20/g20/m10/t0.3": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.603246969006205,
+     "vsdev": 0.674822885038995
+    },
+    "objective": 0.6390349270226
+   },
+   "gap20/g20/m10/t0.35": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6284406701252355,
+     "vsdev": 0.6946455317024465
+    },
+    "objective": 0.661543100913841
+   },
+   "gap20/g20/m10/t0.4": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.646788257649754,
+     "vsdev": 0.7072288364138656
+    },
+    "objective": 0.6770085470318098
+   },
+   "gap20/g20/m10/t0.45": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.6661552182126795,
+     "vsdev": 0.7235114984773705
+    },
+    "objective": 0.694833358345025
+   },
+   "gap20/g20/m10/t0.5": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.6801888260621466,
+     "vsdev": 0.7424438523030072
+    },
+    "objective": 0.711316339182577
+   },
+   "gap20/g20/m10/t0.55": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6838796436375861,
+     "vsdev": 0.7321220203367228
+    },
+    "objective": 0.7080008319871545
+   },
+   "gap20/g20/m10/t0.6": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6748287775016668,
+     "vsdev": 0.7153007195546907
+    },
+    "objective": 0.6950647485281787
+   },
+   "gap20/g20/m10/t0.65": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.6551665777037143,
+     "vsdev": 0.6813744631003514
+    },
+    "objective": 0.6682705204020329
+   },
+   "gap20/g20/m10/t0.7": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.6228790519344719,
+     "vsdev": 0.6232297611498625
+    },
+    "objective": 0.6230544065421673
+   },
+   "gap20/g20/m10/t0.75": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5724501092062353,
+     "vsdev": 0.5741022605558374
+    },
+    "objective": 0.5732761848810364
+   },
+   "gap20/g20/m10/t0.8": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.5173158441973926,
+     "vsdev": 0.5126876017117714
+    },
+    "objective": 0.515001722954582
+   },
+   "gap20/g20/m10/t0.85": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.4251922246220302,
+     "vsdev": 0.4485195797516715
+    },
+    "objective": 0.4368559021868509
+   },
+   "gap20/g20/m10/t0.9": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.3006572876057028,
+     "vsdev": 0.35386721423682416
+    },
+    "objective": 0.3272622509212635
+   },
+   "gap20/g20/m10/t0.95": {
+    "decode": "gap20",
+    "gap": 20,
+    "minc": 10,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.12037095187255333,
+     "vsdev": 0.2511138704258272
+    },
+    "objective": 0.18574241114919027
+   },
+   "gap50/g50/m10/t0.05": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.421694106838296,
+     "vsdev": 0.49190379194699924
+    },
+    "objective": 0.45679894939264765
+   },
+   "gap50/g50/m10/t0.1": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.4697398803727917,
+     "vsdev": 0.5438116478513784
+    },
+    "objective": 0.506775764112085
+   },
+   "gap50/g50/m10/t0.15": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.5052929666135951,
+     "vsdev": 0.5875486381322957
+    },
+    "objective": 0.5464208023729454
+   },
+   "gap50/g50/m10/t0.2": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5386366485651883,
+     "vsdev": 0.6223785541077091
+    },
+    "objective": 0.5805076013364487
+   },
+   "gap50/g50/m10/t0.25": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.5661051412756464,
+     "vsdev": 0.6491321537728177
+    },
+    "objective": 0.607618647524232
+   },
+   "gap50/g50/m10/t0.3": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.5950078500079637,
+     "vsdev": 0.6697805587379924
+    },
+    "objective": 0.632394204372978
+   },
+   "gap50/g50/m10/t0.35": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6204163661558658,
+     "vsdev": 0.6876000492550178
+    },
+    "objective": 0.6540082077054419
+   },
+   "gap50/g50/m10/t0.4": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.6414897592088913,
+     "vsdev": 0.7046383392799221
+    },
+    "objective": 0.6730640492444067
+   },
+   "gap50/g50/m10/t0.45": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.661658382286489,
+     "vsdev": 0.7169437033996854
+    },
+    "objective": 0.6893010428430872
+   },
+   "gap50/g50/m10/t0.5": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.6776113612463883,
+     "vsdev": 0.7425554853340273
+    },
+    "objective": 0.7100834232902078
+   },
+   "gap50/g50/m10/t0.55": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6829612169143159,
+     "vsdev": 0.7335515548281505
+    },
+    "objective": 0.7082563858712332
+   },
+   "gap50/g50/m10/t0.6": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6739054961631012,
+     "vsdev": 0.718813996972665
+    },
+    "objective": 0.6963597465678831
+   },
+   "gap50/g50/m10/t0.65": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.6595473669312816,
+     "vsdev": 0.6863309352517986
+    },
+    "objective": 0.6729391510915401
+   },
+   "gap50/g50/m10/t0.7": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.6313602465670491,
+     "vsdev": 0.6278875300512177
+    },
+    "objective": 0.6296238883091334
+   },
+   "gap50/g50/m10/t0.75": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5780280020742278,
+     "vsdev": 0.5823801818891926
+    },
+    "objective": 0.5802040919817102
+   },
+   "gap50/g50/m10/t0.8": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.5259423503325942,
+     "vsdev": 0.5153205012892007
+    },
+    "objective": 0.5206314258108975
+   },
+   "gap50/g50/m10/t0.85": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.4332932485827177,
+     "vsdev": 0.4595481509529219
+    },
+    "objective": 0.44642069976781984
+   },
+   "gap50/g50/m10/t0.9": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.3114910492152864,
+     "vsdev": 0.3614933914702275
+    },
+    "objective": 0.33649222034275694
+   },
+   "gap50/g50/m10/t0.95": {
+    "decode": "gap50",
+    "gap": 50,
+    "minc": 10,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.1287149347672044,
+     "vsdev": 0.25417426175720015
+    },
+    "objective": 0.19144459826220228
+   },
+   "gap100/g100/m10/t0.05": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.41235796537786934,
+     "vsdev": 0.48271824275216024
+    },
+    "objective": 0.4475381040650148
+   },
+   "gap100/g100/m10/t0.1": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.4621869386462536,
+     "vsdev": 0.5366063154087837
+    },
+    "objective": 0.49939662702751864
+   },
+   "gap100/g100/m10/t0.15": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.49644493977555154,
+     "vsdev": 0.5794622228776484
+    },
+    "objective": 0.5379535813266
+   },
+   "gap100/g100/m10/t0.2": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5307869650813387,
+     "vsdev": 0.6130890052356021
+    },
+    "objective": 0.5719379851584704
+   },
+   "gap100/g100/m10/t0.25": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.559522899304228,
+     "vsdev": 0.641816220999364
+    },
+    "objective": 0.600669560151796
+   },
+   "gap100/g100/m10/t0.3": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.5882563578446367,
+     "vsdev": 0.6662401861006106
+    },
+    "objective": 0.6272482719726237
+   },
+   "gap100/g100/m10/t0.35": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6143040712569736,
+     "vsdev": 0.6818873668188737
+    },
+    "objective": 0.6480957190379237
+   },
+   "gap100/g100/m10/t0.4": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.6374932561465407,
+     "vsdev": 0.6982910078262258
+    },
+    "objective": 0.6678921319863833
+   },
+   "gap100/g100/m10/t0.45": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.6572301991662807,
+     "vsdev": 0.7131219282299872
+    },
+    "objective": 0.6851760636981339
+   },
+   "gap100/g100/m10/t0.5": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.6718590244782583,
+     "vsdev": 0.7396038880362494
+    },
+    "objective": 0.7057314562572539
+   },
+   "gap100/g100/m10/t0.55": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6806150253016737,
+     "vsdev": 0.7351342646644389
+    },
+    "objective": 0.7078746449830563
+   },
+   "gap100/g100/m10/t0.6": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6738635425146592,
+     "vsdev": 0.7259324265028521
+    },
+    "objective": 0.6998979845087556
+   },
+   "gap100/g100/m10/t0.65": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.6657855944695776,
+     "vsdev": 0.6930140098447558
+    },
+    "objective": 0.6793998021571668
+   },
+   "gap100/g100/m10/t0.7": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.6394530081831281,
+     "vsdev": 0.6380272952853597
+    },
+    "objective": 0.6387401517342439
+   },
+   "gap100/g100/m10/t0.75": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5827835975493293,
+     "vsdev": 0.5880070937707825
+    },
+    "objective": 0.5853953456600559
+   },
+   "gap100/g100/m10/t0.8": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.533731062092786,
+     "vsdev": 0.5188055075400846
+    },
+    "objective": 0.5262682848164353
+   },
+   "gap100/g100/m10/t0.85": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.4419139832603175,
+     "vsdev": 0.46503474613410134
+    },
+    "objective": 0.4534743646972094
+   },
+   "gap100/g100/m10/t0.9": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.3179263890439507,
+     "vsdev": 0.36327752824282017
+    },
+    "objective": 0.34060195864338544
+   },
+   "gap100/g100/m10/t0.95": {
+    "decode": "gap100",
+    "gap": 100,
+    "minc": 10,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.13964859937013094,
+     "vsdev": 0.25671641791044775
+    },
+    "objective": 0.19818250864028936
+   },
+   "sent/g0/m0/t0.05": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.4482803837337991,
+     "vsdev": 0.5159132592512677
+    },
+    "objective": 0.4820968214925334
+   },
+   "sent/g0/m0/t0.1": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.4934693781147405,
+     "vsdev": 0.5667411304076289
+    },
+    "objective": 0.5301052542611847
+   },
+   "sent/g0/m0/t0.15": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.5305340557275542,
+     "vsdev": 0.6096960588707797
+    },
+    "objective": 0.5701150572991669
+   },
+   "sent/g0/m0/t0.2": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5604934322608459,
+     "vsdev": 0.6422979380306538
+    },
+    "objective": 0.6013956851457498
+   },
+   "sent/g0/m0/t0.25": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.5904402496960838,
+     "vsdev": 0.6706297170498586
+    },
+    "objective": 0.6305349833729712
+   },
+   "sent/g0/m0/t0.3": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.6145956732947995,
+     "vsdev": 0.686782133090246
+    },
+    "objective": 0.6506889031925227
+   },
+   "sent/g0/m0/t0.35": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6392696382035401,
+     "vsdev": 0.7057705707227466
+    },
+    "objective": 0.6725201044631434
+   },
+   "sent/g0/m0/t0.4": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.6565454860446244,
+     "vsdev": 0.7150262510799494
+    },
+    "objective": 0.6857858685622868
+   },
+   "sent/g0/m0/t0.45": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.6764974604328562,
+     "vsdev": 0.7252023204182483
+    },
+    "objective": 0.7008498904255522
+   },
+   "sent/g0/m0/t0.5": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.686591771382674,
+     "vsdev": 0.748391122898709
+    },
+    "objective": 0.7174914471406915
+   },
+   "sent/g0/m0/t0.55": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6881698315852015,
+     "vsdev": 0.7375688267683186
+    },
+    "objective": 0.71286932917676
+   },
+   "sent/g0/m0/t0.6": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6787939871434014,
+     "vsdev": 0.7121421338488447
+    },
+    "objective": 0.6954680604961231
+   },
+   "sent/g0/m0/t0.65": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.6514106334990832,
+     "vsdev": 0.6775067750677506
+    },
+    "objective": 0.6644587042834169
+   },
+   "sent/g0/m0/t0.7": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.6168765992337815,
+     "vsdev": 0.6161871470825491
+    },
+    "objective": 0.6165318731581653
+   },
+   "sent/g0/m0/t0.75": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5702453202415554,
+     "vsdev": 0.5605635416070099
+    },
+    "objective": 0.5654044309242827
+   },
+   "sent/g0/m0/t0.8": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.5100588852141648,
+     "vsdev": 0.5137437322539721
+    },
+    "objective": 0.5119013087340685
+   },
+   "sent/g0/m0/t0.85": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.41671450689769146,
+     "vsdev": 0.43247775054817494
+    },
+    "objective": 0.4245961287229332
+   },
+   "sent/g0/m0/t0.9": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.2901837349968714,
+     "vsdev": 0.34231750189563664
+    },
+    "objective": 0.316250618446254
+   },
+   "sent/g0/m0/t0.95": {
+    "decode": "sent",
+    "gap": 0,
+    "minc": 0,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.10546083727211343,
+     "vsdev": 0.24881152636583048
+    },
+    "objective": 0.17713618181897195
+   },
+   "sent/g1/m0/t0.05": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.05,
+    "thr": {
+     "acl_val": 0.4482803837337991,
+     "vsdev": 0.5159132592512677
+    },
+    "objective": 0.4820968214925334
+   },
+   "sent/g1/m0/t0.1": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.1,
+    "thr": {
+     "acl_val": 0.4934693781147405,
+     "vsdev": 0.5667411304076289
+    },
+    "objective": 0.5301052542611847
+   },
+   "sent/g1/m0/t0.15": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.15,
+    "thr": {
+     "acl_val": 0.5305340557275542,
+     "vsdev": 0.6096960588707797
+    },
+    "objective": 0.5701150572991669
+   },
+   "sent/g1/m0/t0.2": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.2,
+    "thr": {
+     "acl_val": 0.5604934322608459,
+     "vsdev": 0.6422979380306538
+    },
+    "objective": 0.6013956851457498
+   },
+   "sent/g1/m0/t0.25": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.25,
+    "thr": {
+     "acl_val": 0.5904402496960838,
+     "vsdev": 0.6706297170498586
+    },
+    "objective": 0.6305349833729712
+   },
+   "sent/g1/m0/t0.3": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.3,
+    "thr": {
+     "acl_val": 0.6145956732947995,
+     "vsdev": 0.686782133090246
+    },
+    "objective": 0.6506889031925227
+   },
+   "sent/g1/m0/t0.35": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.35,
+    "thr": {
+     "acl_val": 0.6392696382035401,
+     "vsdev": 0.7057705707227466
+    },
+    "objective": 0.6725201044631434
+   },
+   "sent/g1/m0/t0.4": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.4,
+    "thr": {
+     "acl_val": 0.6565454860446244,
+     "vsdev": 0.7150262510799494
+    },
+    "objective": 0.6857858685622868
+   },
+   "sent/g1/m0/t0.45": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.45,
+    "thr": {
+     "acl_val": 0.6764974604328562,
+     "vsdev": 0.7252023204182483
+    },
+    "objective": 0.7008498904255522
+   },
+   "sent/g1/m0/t0.5": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.5,
+    "thr": {
+     "acl_val": 0.686591771382674,
+     "vsdev": 0.748391122898709
+    },
+    "objective": 0.7174914471406915
+   },
+   "sent/g1/m0/t0.55": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.55,
+    "thr": {
+     "acl_val": 0.6881698315852015,
+     "vsdev": 0.7375688267683186
+    },
+    "objective": 0.71286932917676
+   },
+   "sent/g1/m0/t0.6": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.6,
+    "thr": {
+     "acl_val": 0.6787939871434014,
+     "vsdev": 0.7121421338488447
+    },
+    "objective": 0.6954680604961231
+   },
+   "sent/g1/m0/t0.65": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.65,
+    "thr": {
+     "acl_val": 0.6514106334990832,
+     "vsdev": 0.6775067750677506
+    },
+    "objective": 0.6644587042834169
+   },
+   "sent/g1/m0/t0.7": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.7,
+    "thr": {
+     "acl_val": 0.6168765992337815,
+     "vsdev": 0.6161871470825491
+    },
+    "objective": 0.6165318731581653
+   },
+   "sent/g1/m0/t0.75": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.75,
+    "thr": {
+     "acl_val": 0.5702453202415554,
+     "vsdev": 0.5605635416070099
+    },
+    "objective": 0.5654044309242827
+   },
+   "sent/g1/m0/t0.8": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.8,
+    "thr": {
+     "acl_val": 0.5100588852141648,
+     "vsdev": 0.5137437322539721
+    },
+    "objective": 0.5119013087340685
+   },
+   "sent/g1/m0/t0.85": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.85,
+    "thr": {
+     "acl_val": 0.41671450689769146,
+     "vsdev": 0.43247775054817494
+    },
+    "objective": 0.4245961287229332
+   },
+   "sent/g1/m0/t0.9": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.9,
+    "thr": {
+     "acl_val": 0.2901837349968714,
+     "vsdev": 0.34231750189563664
+    },
+    "objective": 0.316250618446254
+   },
+   "sent/g1/m0/t0.95": {
+    "decode": "sent",
+    "gap": 1,
+    "minc": 0,
+    "threshold": 0.95,
+    "thr": {
+     "acl_val": 0.10546083727211343,
+     "vsdev": 0.24881152636583048
+    },
+    "objective": 0.17713618181897195
+   }
+  }
+ },
+ "span_nb_router_reads": {
+  "setting": {
+   "ckpt": "ckpt-005000",
+   "head": "final",
+   "threshold_defs": 0.6,
+   "threshold_names": 0.6
+  },
+  "sets": {
+   "halu": {
+    "threshold": 0.5,
+    "arm": 0.926123381568926,
+    "B": 0.9098605577689242,
+    "diff": 0.01626282380000188,
+    "lo": 0.008131712656539766,
+    "hi": 0.02430469918397534
+   },
+   "pii_short": {
+    "threshold": 0.55,
+    "arm": 1.0,
+    "B": 1.0,
+    "diff": 0.0,
+    "lo": 0.0,
+    "hi": 0.0
+   },
+   "pii_4096": {
+    "threshold": 0.7,
+    "arm": 0.9824994288325337,
+    "B": 0.9458532623409439,
+    "diff": 0.036646166491589804,
+    "lo": 0.029374776876339125,
+    "hi": 0.045061915519669024
+   },
+   "pii_8192": {
+    "threshold": 0.7,
+    "arm": 0.9881026064232171,
+    "B": 0.9409075322894045,
+    "diff": 0.04719507413381263,
+    "lo": 0.03929405204950289,
+    "hi": 0.055152603156618026
+   },
+   "toxic": {
+    "threshold": 0.4,
+    "arm": 0.6863406068958801,
+    "n": 2013,
+    "at_060": 0.6639200978263368
+   }
+  }
+ },
+ "ner_pick": {
+  "group": "N5",
+  "rule": "option B: max mean of (ner_shift ens eval F1, hierarchical names eval F1) over the run's checkpoints (dev only; coordinator 18 Oct)",
+  "choice": {
+   "tag": "N5",
+   "ckpt": "ckpt-006000",
+   "mode": "defs",
+   "ckpt_dir": "N5/ckpt-006000",
+   "threshold": 0.6,
+   "thr_f1": 0.7530477185649599,
+   "eval_f1": 0.743403577120595,
+   "rule_choice": {
+    "tag": "N5",
+    "ckpt": "ckpt-006000",
+    "mode": "ens",
+    "ckpt_dir": "N5/ckpt-006000",
+    "threshold": 0.6,
+    "thr_f1": 0.7530477185649599,
+    "eval_f1": 0.7483064095883273
+   }
+  },
+  "all": {
+   "N5/ckpt-001000/names": {
+    "threshold": 0.55,
+    "thr_f1": 0.711567603973733,
+    "eval_f1": 0.7188132164531356
+   },
+   "N5/ckpt-001000/defs": {
+    "threshold": 0.5,
+    "thr_f1": 0.7315898141775636,
+    "eval_f1": 0.7305450805622214
+   },
+   "N5/ckpt-001000/ens": {
+    "threshold": 0.55,
+    "thr_f1": 0.7274622199062012,
+    "eval_f1": 0.726957726957727
+   },
+   "N5/ckpt-002000/names": {
+    "threshold": 0.65,
+    "thr_f1": 0.7281604184829992,
+    "eval_f1": 0.7393939393939394
+   },
+   "N5/ckpt-002000/defs": {
+    "threshold": 0.6,
+    "thr_f1": 0.7520949720670391,
+    "eval_f1": 0.7453092425295343
+   },
+   "N5/ckpt-002000/ens": {
+    "threshold": 0.65,
+    "thr_f1": 0.7497761060361813,
+    "eval_f1": 0.7517401392111369
+   },
+   "N5/ckpt-003000/names": {
+    "threshold": 0.7,
+    "thr_f1": 0.7319718055304536,
+    "eval_f1": 0.7309163782109674
+   },
+   "N5/ckpt-003000/defs": {
+    "threshold": 0.55,
+    "thr_f1": 0.7521457348046944,
+    "eval_f1": 0.747913769123783
+   },
+   "N5/ckpt-003000/ens": {
+    "threshold": 0.65,
+    "thr_f1": 0.7535863446522607,
+    "eval_f1": 0.7472687545520758
+   },
+   "N5/ckpt-004000/names": {
+    "threshold": 0.6,
+    "thr_f1": 0.725059181602976,
+    "eval_f1": 0.7325033647375505
+   },
+   "N5/ckpt-004000/defs": {
+    "threshold": 0.6,
+    "thr_f1": 0.7489885664028144,
+    "eval_f1": 0.7421273617914625
+   },
+   "N5/ckpt-004000/ens": {
+    "threshold": 0.6,
+    "thr_f1": 0.7428967428967429,
+    "eval_f1": 0.7460207612456747
+   },
+   "N5/ckpt-005000/names": {
+    "threshold": 0.6,
+    "thr_f1": 0.723158073847201,
+    "eval_f1": 0.7315995240523543
+   },
+   "N5/ckpt-005000/defs": {
+    "threshold": 0.6,
+    "thr_f1": 0.7502228561240862,
+    "eval_f1": 0.738998752895065
+   },
+   "N5/ckpt-005000/ens": {
+    "threshold": 0.6,
+    "thr_f1": 0.7474109180270317,
+    "eval_f1": 0.7454832485528855
+   },
+   "N5/ckpt-006000/names": {
+    "threshold": 0.65,
+    "thr_f1": 0.7306954854453547,
+    "eval_f1": 0.7393050462720447
+   },
+   "N5/ckpt-006000/defs": {
+    "threshold": 0.6,
+    "thr_f1": 0.754324038122132,
+    "eval_f1": 0.743403577120595
+   },
+   "N5/ckpt-006000/ens": {
+    "threshold": 0.6,
+    "thr_f1": 0.7530477185649599,
+    "eval_f1": 0.7483064095883273
+   }
+  }
+ },
+ "decision_pick": {
+  "all": {
+   "decision/ckpt-000500": {
+    "domain": 0.8353078403176649,
+    "factcheck": 1.0,
+    "modality": 1.0,
+    "feedback": 0.8754390740219427,
+    "p_harm": 0.9496608383549013,
+    "r_harm": 0.9499804823039556,
+    "r_refusal": 0.9736039688818565,
+    "attack": 0.985854398012858,
+    "massive_intent": 0.8271428571428572,
+    "massive_scenario": 0.8585714285714285,
+    "sgd_intent": 0.7285714285714285,
+    "objective": 0.9076483923798992
+   },
+   "decision/ckpt-001000": {
+    "domain": 0.8594206483249511,
+    "factcheck": 1.0,
+    "modality": 1.0,
+    "feedback": 0.8961194543161756,
+    "p_harm": 0.9494056439132009,
+    "r_harm": 0.9558791637751561,
+    "r_refusal": 0.9834684862869199,
+    "attack": 0.9901647428404442,
+    "massive_intent": 0.8085714285714286,
+    "massive_scenario": 0.8714285714285714,
+    "sgd_intent": 0.7414285714285714,
+    "objective": 0.9141715191714017
+   },
+   "decision/ckpt-001500": {
+    "domain": 0.9151463419642936,
+    "factcheck": 1.0,
+    "modality": 1.0,
+    "feedback": 0.9461140117693847,
+    "p_harm": 0.9550199216306101,
+    "r_harm": 0.9686090388619014,
+    "r_refusal": 0.9842184203586498,
+    "attack": 0.9923381794272356,
+    "massive_intent": 0.82,
+    "massive_scenario": 0.8728571428571429,
+    "sgd_intent": 0.7471428571428571,
+    "objective": 0.9274041740010976
+   },
+   "decision/ckpt-002000": {
+    "domain": 0.8867539765596268,
+    "factcheck": 1.0,
+    "modality": 1.0,
+    "feedback": 0.9572017043930406,
+    "p_harm": 0.95554677467154,
+    "r_harm": 0.9695090215128384,
+    "r_refusal": 0.9867648997890295,
+    "attack": 0.9924295002922268,
+    "massive_intent": 0.8328571428571429,
+    "massive_scenario": 0.8785714285714286,
+    "sgd_intent": 0.7557142857142857,
+    "objective": 0.9286680667601054
+   },
+   "decision/ckpt-002500": {
+    "domain": 0.9159579646703421,
+    "factcheck": 1.0,
+    "modality": 1.0,
+    "feedback": 0.9662754728998316,
+    "p_harm": 0.9576212585202015,
+    "r_harm": 0.9725559507286606,
+    "r_refusal": 0.9895668512658228,
+    "attack": 0.9933244447691408,
+    "massive_intent": 0.8371428571428572,
+    "massive_scenario": 0.8728571428571429,
+    "sgd_intent": 0.7685714285714286,
+    "objective": 0.9339884883114027
+   },
+   "decision/ckpt-003000": {
+    "domain": 0.9138646944455209,
+    "factcheck": 1.0,
+    "modality": 1.0,
+    "feedback": 0.965409106329435,
+    "p_harm": 0.9593006025881655,
+    "r_harm": 0.9729137751561415,
+    "r_refusal": 0.990745319092827,
+    "attack": 0.9936075394506136,
+    "massive_intent": 0.8442857142857143,
+    "massive_scenario": 0.8814285714285715,
+    "sgd_intent": 0.7614285714285715,
+    "objective": 0.934816717655051
+   }
+  },
+  "choice": "decision/ckpt-003000"
+ },
+ "source": "Phase D final build on the 8x (d3-flash); round-2 selection",
+ "picks": {
+  "decision": {
+   "D": "A",
+   "S": "B",
+   "N": "B",
+   "L": "B"
+  },
+  "why": {
+   "approved": {
+    "by": "coordinator 18 Oct (option B adopted)",
+    "note": "S=B at the arm's own pick (ckpt-006000): round 2 clearly helps the 9B span adapter at all three B ckpts, not just one - evidence +.035 to +.041 (.705-.711 vs .670), halu +.013 (.922-.923 vs .909), toxic +.01 to +.025; ner_shift level (.708-.712 vs .707); PII short equal, PII 4K/8K mixed within CI. 6000 vs 8000 is within noise (8000 has evidence .711 but PII 4K .975); keep 6000 so L-B (trained from it) needs no retrain. L=B follows. N=B@ckpt-020000 ens: B above A at matched late training (20-24k avg .740 vs .712, +.028), the rule's pick is late and well trained. D=A. | 18 Oct option B: N5 = the coarse+fine continuation ckpt-006000 (best mean of ner_shift ens and hierarchical names, dev), names-only open labels on the NER adapter | KD S 2026-10-19T08:57:30Z"
+   },
+   "rule_proposal": {
+    "D": "A",
+    "S": "B",
+    "N": "B",
+    "L": "B"
+   },
+   "rule_why": {
+    "S": "ner_shift eval F1 B 0.7116 vs A 0.7066 (higher); evidence dev B 0.7050 vs A 0.6699 (ok); spanread drops: none -> B",
+    "N": "N5 eval F1 B 0.7475 (ckpt-020000 ens) vs A 0.7298 (ckpt-014000 defs) -> B",
+    "L": "follows S (B)",
+    "D": "decision LoRA not retrained in round 2 (A)"
+   },
+   "S_src": "flash_kdS/up",
+   "N_src": "ob_flash/up",
+   "N_ckpt": {
+    "ckpt": "ckpt-006000",
+    "dir": "N5/ckpt-006000",
+    "reads": {
+     "names": {
+      "threshold": 0.65,
+      "thr_f1": 0.7306954854453547,
+      "eval_f1": 0.7393050462720447
+     },
+     "defs": {
+      "threshold": 0.6,
+      "thr_f1": 0.754324038122132,
+      "eval_f1": 0.743403577120595
+     },
+     "ens": {
+      "threshold": 0.6,
+      "thr_f1": 0.7530477185649599,
+      "eval_f1": 0.7483064095883273
+     }
+    }
+   }
+  }
+ },
+ "router_gate": "not measured at this size (id gate)"
+}

config.json

@@ -0,0 +1,115 @@
+{
+  "architectures": [
+    "Qwen3_5Model"
+  ],
+  "dtype": "bfloat16",
+  "image_token_id": 248056,
+  "model_type": "qwen3_5",
+  "text_config": {
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "attn_output_gate": true,
+    "bos_token_id": null,
+    "dtype": "bfloat16",
+    "eos_token_id": 248044,
+    "full_attention_interval": 4,
+    "head_dim": 256,
+    "hidden_act": "silu",
+    "hidden_size": 4096,
+    "initializer_range": 0.02,
+    "intermediate_size": 12288,
+    "layer_types": [
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention",
+      "linear_attention",
+      "linear_attention",
+      "linear_attention",
+      "full_attention"
+    ],
+    "linear_conv_kernel_dim": 4,
+    "linear_key_head_dim": 128,
+    "linear_num_key_heads": 16,
+    "linear_num_value_heads": 32,
+    "linear_value_head_dim": 128,
+    "mamba_ssm_dtype": "float32",
+    "max_position_embeddings": 262144,
+    "mlp_only_layers": [],
+    "model_type": "qwen3_5_text",
+    "mtp_num_hidden_layers": 1,
+    "mtp_use_dedicated_embeddings": false,
+    "num_attention_heads": 16,
+    "num_hidden_layers": 32,
+    "num_key_value_heads": 4,
+    "pad_token_id": null,
+    "partial_rotary_factor": 0.25,
+    "rms_norm_eps": 1e-06,
+    "rope_parameters": {
+      "mrope_interleaved": true,
+      "mrope_section": [
+        11,
+        11,
+        10
+      ],
+      "partial_rotary_factor": 0.25,
+      "rope_theta": 10000000,
+      "rope_type": "default"
+    },
+    "tie_word_embeddings": false,
+    "use_cache": true,
+    "vocab_size": 248320
+  },
+  "tie_word_embeddings": false,
+  "transformers_version": "5.17.0",
+  "video_token_id": 248057,
+  "vision_config": {
+    "deepstack_visual_indexes": [],
+    "depth": 27,
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "in_channels": 3,
+    "initializer_range": 0.02,
+    "intermediate_size": 4304,
+    "model_type": "qwen3_5_vision",
+    "num_heads": 16,
+    "num_position_embeddings": 2304,
+    "out_hidden_size": 4096,
+    "patch_size": 16,
+    "rope_parameters": {
+      "rope_theta": 10000.0,
+      "rope_type": "axial"
+    },
+    "spatial_merge_size": 2,
+    "temporal_patch_size": 2
+  },
+  "vision_end_token_id": 248054,
+  "vision_start_token_id": 248053,
+  "auto_map": {
+    "AutoModel": "modeling_vela3.Vela3MiniModel"
+  }
+}

decision_df_lora.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:713622285c348d885ffdd9b6199cd8540f6435d172b2048a04239a7ee42cbb4f
+size 240689128

decision_lora.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:369df81e576fd54ef3c98c5f48fca88892f2bd38c72b159c91348eb410e72b5e
+size 240689096

image_halu_head.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6ec4981046337e0e7e1bf9696ce15d281bdd691188f1adb33e6a8d53466ff0d
+size 17910988

image_halu_lora.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64d5b39a3997b0263d56e737878e3c4937177fefc30f83d5649880a88433455b
+size 240668960

label_definitions.json

@@ -0,0 +1,13 @@
+{
+ "about": "label-definition cache (looked up by label set, order-insensitive); ships empty: no benchmark label set is cached (17 Oct)",
+ "sets": [],
+ "removed": [
+  "OOD-7 CrossNER_AI",
+  "OOD-7 CrossNER_literature",
+  "OOD-7 CrossNER_music",
+  "OOD-7 CrossNER_politics",
+  "OOD-7 CrossNER_science",
+  "OOD-7 mit-movie",
+  "OOD-7 mit-restaurant"
+ ]
+}

labeldef_lm_head.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d43ed7f6b0af94195d6ea687a59141384a4fba5a3756016aade8c9c0c208662
+size 2034237664

modeling_vela3.py

@@ -0,0 +1,417 @@
+"""Vela-3.0-4B for Transformers (trust_remote_code=True).
+
+    m = AutoModel.from_pretrained("vllm-sr/Vela-3.0-4B", trust_remote_code=True)
+    m.system_one(state=..., questions={...})
+
+The base model is vllm-sr/d3-mini at the revision pinned in vela3_config.json, loaded through d3's own runtime; its weights are
+not changed. Two gated LoRA adapters sit on its Linear layers (vela3_adapters.py):
+  * decision adapter: on only for the rows of the built-in router question ids (vela3_config.json "router_question_ids"; with
+    "router_gate": "id_and_wording" only when the question also uses the trained wording of router_questions.json), in
+    d3's own batching. Every other Choice / Noul / Score question runs with all adapters off, i.e. exactly as d3-mini.
+  * P5: a decision opt-in adapter (adapters.decision_optin, D1e): a question that is not a router question id and sets
+    "decision_adapter": true runs with it; router question ids always keep the decision adapter; without the key, nothing changes.
+  * P5: a relation adapter (adapters.relation + span.relation, R5S): relation questions only ("Which spans are the <relation> of
+    <head>?", "Which spans are related to <head> by these relations?"; the relation rule of _span_route); everything else as below.
+  * two span adapters, routed by label family (vela3_config.json span.ner.route; _span_route below): open-label entity
+    questions run on the NER adapter and its head (ner_lora / ner_head.safetensors); relation questions, evidence / answer
+    questions and the router label sets (PII, halu, toxic) run on the span adapter and its head (span_lora / span_head).
+    A question of type "span" costs one extra forward pass (more for long targets), read on the final-norm states (vela3_span.py).
+    With images, span questions read them in the same pass (d3's image layout); a halu question then takes span.image_halu.
+Open-label span questions get one-line label definitions written by d3-mini itself (adapters off, causal attention;
+vela3_labeldef.py) unless "definitions" says otherwise."""
+from __future__ import annotations
+
+import importlib.util
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import torch
+from transformers import PreTrainedModel
+from transformers.models.qwen3_5.configuration_qwen3_5 import Qwen3_5Config
+
+HERE = Path(__file__).resolve().parent
+
+
+def _load_local(name, path):
+    spec = importlib.util.spec_from_file_location(name, str(path)); mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod; spec.loader.exec_module(mod); return mod
+
+
+def _resolve(name_or_path, revision=None, **hub):
+    p = Path(os.fspath(name_or_path)).expanduser()
+    if p.is_dir():
+        return p
+    from huggingface_hub import snapshot_download
+    return Path(snapshot_download(str(name_or_path), revision=revision, **{k: v for k, v in hub.items() if v is not None}))
+
+
+class Vela3MiniModel(PreTrainedModel):
+    config_class = Qwen3_5Config
+    base_model_prefix = "vela3"
+    _no_split_modules = []
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.d3 = None; self.span = None; self.vela3_config = None; self.defs = None
+        self.post_init()
+
+    def _init_weights(self, module):
+        """Nothing is initialised here: base weights come from d3-mini, adapters and the span head from this repository."""
+
+    @classmethod
+    def from_pretrained(cls, pretrained_model_name_or_path, *args, config=None, **kwargs):
+        """kwargs: device / device_map, batch_size, verify (passed to d3); revision, token, cache_dir, local_files_only (this repo);
+        base_path: a local d3-mini snapshot to use instead of downloading vllm-sr/d3-mini at the pinned revision."""
+        hub = {k: kwargs.pop(k) for k in ("token", "cache_dir", "local_files_only", "force_download") if k in kwargs}
+        revision = kwargs.pop("revision", None)
+        root = _resolve(pretrained_model_name_or_path, revision, **hub)
+        vc = json.loads((root / "vela3_config.json").read_text())
+        base_path = kwargs.pop("base_path", None)
+        d3_kw = {k: kwargs.pop(k) for k in ("device", "device_map", "batch_size", "verify") if k in kwargs}
+        for k in ("trust_remote_code", "_from_auto", "_from_pipeline", "adapter_kwargs", "code_revision", "_commit_hash", "dtype", "torch_dtype"):
+            kwargs.pop(k, None)
+        from transformers import AutoModel
+        base = base_path or vc["base"]["repo_id"]
+        d3 = AutoModel.from_pretrained(base, revision=None if base_path else vc["base"]["revision"], trust_remote_code=True, **d3_kw,
+                                       **{k: v for k, v in hub.items() if k != "force_download"})
+        rt = d3.runtime
+        d3_format = _load_local("vela3_d3_format", Path(rt.root) / "d3_format.py")
+        A = _load_local("vela3_adapters", root / "vela3_adapters.py")
+        vs = _load_local("vela3_span", root / "vela3_span.py")
+        ld = _load_local("vela3_labeldef", root / "vela3_labeldef.py")
+        dec = _load_local("vela3_span_decode", root / "span_decode_v2.py")
+        lm = rt.backbone.language_model
+        info = {name: A.attach(lm, name, root / spec["file"]) for name, spec in vc["adapters"].items()}
+        for name, spec in vc["adapters"].items():
+            if (info[name]["r"], info[name]["alpha"], info[name]["modules"]) != (spec["r"], spec["alpha"], spec["modules"]):
+                raise ValueError(f"adapter {name} does not match vela3_config.json: {info[name]}")
+        rt.backbone.eval()
+        from safetensors.torch import load_file
+        h = vs.SpanHeadV2(rt.backbone.config.text_config.hidden_size)
+        h.load_state_dict(load_file(str(root / vc["span"]["head_file"])), strict=True)
+        model = cls(config or Qwen3_5Config.from_pretrained(str(root)))
+        model.d3, model.vela3_config, model._decode, model._A = d3, vc, dec, A
+        model.span = vs.SpanEngine(rt, h.to(rt.device).eval(), A, d3_format)
+        model.span_ner = None
+        if vc["span"].get("ner"):
+            hn = vs.SpanHeadV2(rt.backbone.config.text_config.hidden_size)
+            hn.load_state_dict(load_file(str(root / vc["span"]["ner"]["head_file"])), strict=True)
+            model.span_ner = vs.SpanEngine(rt, hn.to(rt.device).eval(), A, d3_format, adapter="ner")
+        model.span_img = None  # R5: separate image-halu adapter (span.image_halu.head_file + adapters.image_halu)
+        _ih = vc["span"].get("image_halu") or {}
+        if _ih.get("head_file") and "image_halu" in vc["adapters"]:
+            hi = vs.SpanHeadV2(rt.backbone.config.text_config.hidden_size)
+            hi.load_state_dict(load_file(str(root / _ih["head_file"])), strict=True)
+            model.span_img = vs.SpanEngine(rt, hi.to(rt.device).eval(), A, d3_format, adapter="image_halu")
+        model.span_rel = None  # P5: relation adapter (span.relation.head_file + adapters.relation), relation questions only
+        _rl = vc["span"].get("relation") or {}
+        if _rl.get("head_file") and "relation" in vc["adapters"]:
+            hr = vs.SpanHeadV2(rt.backbone.config.text_config.hidden_size)
+            hr.load_state_dict(load_file(str(root / _rl["head_file"])), strict=True)
+            model.span_rel = vs.SpanEngine(rt, hr.to(rt.device).eval(), A, d3_format, adapter="relation")
+        model.defs = ld.LabelDefiner(rt, A, root / vc["definitions"]["cache_file"])
+        model.router_qids = frozenset(vc["router_question_ids"])
+        rq = json.loads((root / vc["router_questions_file"]).read_text())["trained_questions"]
+        model.router_wordings = {}
+        for qid, v in rq.items():  # trained instruction texts per id (intent: MASSIVE and SGD)
+            vs_ = [v] if "question" in v else list(v.values())
+            model.router_wordings[qid] = {" ".join(x["question"]["instructions"].split()) for x in vs_}
+        model.router_gate = vc.get("router_gate", "id")
+        model.name_or_path = str(pretrained_model_name_or_path)
+        model.eval()
+        return model
+
+    # ------------------------------------------------------------------ API
+    @property
+    def runtime(self):
+        return self.d3.runtime
+
+    # ---------------------------------------------------------------- decisions
+    def decide(self, state, questions, images=None):
+        """d3's System One with the decision adapter on the rows of router question ids. Mirrors D3.run's batching exactly
+        (request order, batch_size per pass, left padding); rows of other ids keep base(x) bit for bit (row-gated LoRA).
+        Requests with images run through d3 unchanged (adapters off)."""
+        rt = self.runtime
+        optin = {k for k, q in questions.items() if isinstance(q, dict) and q.get("decision_adapter") is True} if self.vela3_config.get("decision_opt_in") else set()
+        raw = questions  # R5: "decision_adapter" is ours, never passed to d3
+        questions = {k: ({a: b for a, b in q.items() if a != "decision_adapter"} if isinstance(q, dict) else q) for k, q in questions.items()}
+        prepared = rt.prepare(state, questions, images)
+        router = {k for k in prepared.runnable if self._router_row(k, raw.get(k))}
+        _ta = self.vela3_config.get("decision_task_adapters") or {}  # RDF: domain / feedback rows -> their own adapter, own pass
+        task = {k: _ta[k] for k in router if k in _ta}
+        router = router - set(task)
+        oname = "decision_optin" if "decision_optin" in self.vela3_config["adapters"] else "decision"
+        opt = {k for k in prepared.runnable if k in optin and k not in router}
+        if oname == "decision":
+            router, opt = router | opt, set()
+        gated = router | opt | set(task)
+        if prepared.images or not gated:
+            probs, tokens = rt.run(prepared)
+            return rt.respond(prepared, probs, tokens)
+        keys = prepared.runnable; out = {}
+        for start in range(0, len(keys), rt.batch_size):
+            chunk = keys[start:start + rt.batch_size]
+            args = ([prepared.sequences[k] for k in chunk], [len(prepared.questions[k].keys) for k in chunk])
+            rr = [k in router for k in chunk]; ro = [k in opt for k in chunk]
+            mk = lambda rows: None if all(rows) else torch.as_tensor(rows, device=rt.device)  # noqa: E731
+            passes = ([("decision", rr)] if any(rr) else []) + [(n, [task.get(k) == n for k in chunk]) for n in sorted(set(task.values())) if any(task.get(k) == n for k in chunk)] + ([(oname, ro)] if any(ro) else [])
+            if not passes:
+                probs = rt.probabilities(*args)
+            else:  # one pass per adapter (P4 behaviour: rows off a pass's gate keep base(x) bit for bit); the first pass answers the rows no later pass owns
+                probs = None
+                for name, rows in passes:
+                    with self._A.active(name, mk(rows)):
+                        po = list(rt.probabilities(*args))
+                    probs = po if probs is None else [po[i] if rows[i] else probs[i] for i in range(len(chunk))]
+            out.update(zip(chunk, probs))
+        return rt.respond(prepared, out, sum(len(prepared.sequences[k]) for k in keys))
+
+    def _router_row(self, qid, q):
+        """Decision adapter on for this question? id gate, or id AND the trained wording (router_gate "id_and_wording")."""
+        if qid not in self.router_qids:
+            return False
+        if self.router_gate != "id_and_wording":
+            return True
+        ins = (q or {}).get("instructions") if isinstance(q, dict) else None
+        return ins is not None and " ".join(str(ins).split()) in self.router_wordings.get(qid, set())
+
+    # -------------------------------------------------------------------- spans
+    def _label_set(self, names):
+        sets = self.vela3_config["span"]["router_label_sets"]
+        hit = next((k for k, ls in sets.items() if names and set(names) <= set(ls)), None)
+        ev = self.vela3_config["span"].get("evidence")
+        if hit is None and ev and names and {n.strip().lower() for n in names} <= {x.lower() for x in ev["labels"]}:
+            return "evidence"
+        return hit
+
+    _REL = None
+
+    def _span_route(self, lset, names, instructions):
+        """Which span adapter answers (vela3_config.json span.ner.route): "ner" (NER adapter) for open labels asked as an entity
+        question (no instructions, or instructions that name entities / types / categories and match no relation, answer or
+        evidence pattern); "span" (span adapter) for everything else: router label sets (PII, halu, toxic), evidence / answer
+        labels, relation questions ("Which spans are the <relation> of <head>?"), answer / evidence questions, other wordings.
+        Returns (engine, reason)."""
+        import re
+        if self.span_ner is None:
+            return "span", "span adapter"
+        if lset is not None:
+            return "span", f"{lset} label set: span adapter"
+        if {n.strip().lower() for n in names} & {"answer", "answers"}:
+            return "span", "answer label: span adapter"
+        if Vela3MiniModel._REL is None:
+            Vela3MiniModel._REL = (
+                re.compile(r"\bspans? (?:are|is) the .+ (?:of|for)\b|\brelat(?:ed|ion|ions|es|ing)?\b|\b(?:head|tail)\b|\bstands? in\b"
+                           r"|\bwith respect to\b|\bcounterpart\b|\bsuch that\b|\brole of\b"),
+                re.compile(r"\b(?:answers?|evidence|support(?:s|ing|ed)?|cite[sd]?|citations?)\b"),
+                re.compile(r"\b(?:entit(?:y|ies)|types?|categor(?:y|ies)|named)\b"))
+        ins = " ".join(str(instructions or "").split()).lower()
+        if not ins:
+            return "ner", "open labels, default entity question: NER adapter"
+        if Vela3MiniModel._REL[0].search(ins):
+            if getattr(self, "span_rel", None) is not None:
+                return "rel", "relation question: relation adapter"
+            return "span", "relation question: span adapter"
+        if Vela3MiniModel._REL[1].search(ins):
+            return "span", "answer / evidence question: span adapter"
+        if Vela3MiniModel._REL[2].search(ins):
+            return "ner", "open labels, entity question: NER adapter"
+        return "span", "open labels, other question: span adapter"
+
+    def _threshold(self, lset, n_tok):
+        sp = self.vela3_config["span"]
+        if lset == "pii":
+            b = next(b for b in sp["pii_buckets"] if n_tok <= b["max_tokens"])
+            return float(b["threshold"]), f"pii label set, {b['name']} bucket ({n_tok} target tokens)"
+        if lset == "evidence":
+            return float(sp["evidence"]["threshold"]), "evidence label set (decoding: %s)" % sp["evidence"]["decode"]["name"]
+        if lset in sp["thresholds_by_set"]:
+            return float(sp["thresholds_by_set"][lset]), f"{lset} label set"
+        return float(sp["threshold"]), "open labels"
+
+    def span_answer(self, state, q, images=None):
+        if isinstance(state, str):
+            parts = [("user", state)]
+        elif isinstance(state, dict) and state and all(isinstance(v, str) for v in state.values()):
+            parts = list(state.items())
+        else:
+            raise ValueError("span questions need a text state or an object of text parts")
+        roles = [r for r, _ in parts]
+        target = q.get("target") or ("answer" if "answer" in roles else roles[-1])
+        if target not in roles:
+            raise ValueError(f"target {target!r} is not a part of the state")
+        crit = q.get("criteria") or q.get("labels")
+        if isinstance(crit, dict):
+            labels = [(str(k), "" if v is None else str(v)) for k, v in crit.items()]
+        elif isinstance(crit, (list, tuple)):
+            labels = [(str(k), "") for k in crit]
+        else:
+            raise ValueError("span questions need criteria: {label: description or null} or a list of labels")
+        if not 1 <= len(labels) <= 255:
+            raise ValueError("a span question needs 1 to 255 labels")
+        names = [n for n, _ in labels]
+        if len(set(names)) != len(names):
+            raise ValueError("span labels must be distinct")
+        sp = self.vela3_config["span"]; lset = self._label_set(names)
+        question = q.get("instructions")
+        route, route_why = self._span_route(lset, names, question)
+        img_halu = bool(images) and lset == "halu" and "image_halu" in sp
+        if lset in sp["schemas"]:  # trained router schema: its question text and label descriptions fill what the request leaves empty
+            sch = sp["image_halu"] if img_halu else sp["schemas"][lset]
+            labels = [(n, d or sch["labels"].get(n, "")) for n, d in labels]
+            question = question or sch["question"]
+        if lset == "evidence":
+            question = question or sp["evidence"]["question"]
+        question = question or sp["default_question"]
+        # label definitions: "auto" (default for open labels) = d3-mini writes one for each label without a description;
+        # a dict = given definitions; None / False = names only. Router label sets default to None.
+        mode = q.get("definitions", "auto" if lset is None else None)
+        used = {}
+        if mode == "auto":
+            empty = [n for n, d in labels if not d]
+            used = self.defs.define(names, only=set(empty)) if empty else {}
+        elif isinstance(mode, dict):
+            used = {str(k): str(v) for k, v in mode.items() if str(k) in names}
+        elif mode not in (None, False):
+            raise ValueError('definitions must be "auto", an object {label: definition} or null')
+        labels = [(n, used.get(n) or d) for n, d in labels]
+        if route == "ner" and not any(d for _, d in labels) and (sp.get("ner") or {}).get("names_only_route", "span") != "ner":  # names only: span adapter unless span.ner.names_only_route is "ner" (X8 option B)
+            route, route_why = "span", "open labels, names only: span adapter"
+        eng = self.span_ner if route == "ner" else (self.span_rel if route == "rel" else self.span)
+        if img_halu and route != "ner" and getattr(self, "span_img", None) is not None:  # R5: image-halu adapter
+            eng, route, route_why = self.span_img, "image_halu", route_why + "; image-halu adapter"
+        wo, lg, n_tok, n_win = eng.logits(parts, target, question, labels, images=images)
+        if route == "ner":  # the NER adapter's dev picks: with definitions / descriptions, and names only
+            nr = sp["ner"]; described = any(d for _, d in labels)
+            thr0 = float(nr["threshold"] if described else nr["threshold_names_only"])
+            why = "open labels, " + ("with definitions" if described else "names only")
+        elif img_halu:
+            thr0, why = float(sp["image_halu"]["threshold"]), "halu label set with images (span.image_halu)"
+        else:
+            thr0, why = self._threshold(lset, n_tok)
+            # X8: relation / names-only thresholds (dev picks)
+            _rl = sp.get("relation") or {}; _pair = len(labels) == 1
+            _rt = _rl.get("threshold_dev_pair" if _pair else "threshold_dev_multi")
+            if route == "rel" and isinstance(_rt, (int, float)):
+                thr0, why = float(_rt), "relation adapter (%s; RE dev threshold)" % ("one relation" if _pair else "several relations")
+            elif route == "span" and lset is None and not any(d for _, d in labels) and sp.get("threshold_names_only") is not None:
+                thr0, why = float(sp["threshold_names_only"]), "open labels, names only"
+        thr = float(q.get("threshold", thr0))
+        text = dict(parts)[target]
+        if len(wo) == 0:
+            spans = []
+        else:
+            p = 1 / (1 + np.exp(-lg.astype(np.float64)))
+            if lset == "evidence":
+                spans = self._evidence_spans(p, wo, names, text, thr, sp["evidence"]["decode"])
+            else:
+                spans = self._decode.decode_v2(p, wo, names, text, thr, extend=False) if p.max() > thr else []
+            for s in spans:
+                k = names.index(s["label"]); m = (wo[:, 0] < s["end"]) & (wo[:, 1] > s["start"])
+                s["text"] = text[s["start"]:s["end"]]; s["score"] = float(p[m, k].mean()) if m.any() else 0.0
+        out = {"type": "span", "target": target, "spans": spans, "head": route, "head_reason": f"{route_why}; {why}", "threshold": thr}
+        if used:
+            out["definitions"] = used
+        return out
+
+    _SENT = None
+
+    @staticmethod
+    def _paras(text):
+        import re
+        out, pos = [], 0
+        for blk in re.split(r"(\n\s*\n|\n)", text):
+            if blk and not re.fullmatch(r"\s*", blk):
+                out.append((pos, pos + len(blk)))
+            pos += len(blk)
+        return out
+
+    def _para_spans(self, pk, wo, text, thr, name):
+        """R5 evidence decodes: "para" keeps a paragraph when its mean word probability reaches thr; "sentfill" keeps sentences at thr and
+        fills a paragraph when at least half of its sentences are kept (r5_eval.decode2)."""
+        import re
+        if Vela3MiniModel._SENT is None:
+            Vela3MiniModel._SENT = re.compile(r"[^.!?\n]+(?:[.!?]+|\n|$)")
+        spans = []
+        if name == "para":
+            for a, b in self._paras(text):
+                k = (wo[:, 0] >= a) & (wo[:, 1] <= b)
+                if k.any() and pk[k].mean() >= thr:
+                    spans.append([a, b])
+            return spans
+        sent = [(m.start(), m.end()) for m in Vela3MiniModel._SENT.finditer(text)]
+        keep = []
+        for a, b in sent:
+            k = (wo[:, 0] >= a) & (wo[:, 1] <= b)
+            keep.append(bool(k.any() and pk[k].mean() >= thr))
+        for a, b in self._paras(text):
+            inside = [i for i, (x, y) in enumerate(sent) if x >= a and y <= b]
+            if inside and sum(keep[i] for i in inside) * 2 >= len(inside):
+                spans.append([a, b])
+            else:
+                spans += [list(sent[i]) for i in inside if keep[i]]
+        return spans
+
+    def _evidence_spans(self, p, wo, names, text, thr, dc):
+        """Evidence decoding picked on dev (ACL silver validation + RAGBench verbatim dev): "sent" keeps a sentence when the mean
+        word probability of its first label reaches the threshold; "plain" is the word decoder; then spans <= gap characters apart
+        are merged and spans shorter than min_chars dropped. One label (the first) carries the evidence spans."""
+        import re
+        pk = p[:, 0]
+        if dc["name"] in ("para", "sentfill"):  # R5: paragraph-scale decodes (picked on the gold-like ACL dev)
+            spans = self._para_spans(pk, wo, text, thr, dc["name"])
+        elif dc["name"] == "sent":
+            if Vela3MiniModel._SENT is None:
+                Vela3MiniModel._SENT = re.compile(r"[^.!?\n]+(?:[.!?]+|\n|$)")
+            spans = []
+            for m in Vela3MiniModel._SENT.finditer(text):
+                a, b = m.start(), m.end(); k = (wo[:, 0] >= a) & (wo[:, 1] <= b)
+                if k.any() and pk[k].mean() >= thr:
+                    spans.append([a, b])
+        else:
+            spans = [[s["start"], s["end"]] for s in self._decode.decode_v2(pk[:, None], wo, names[:1], text, thr, extend=False)] if pk.max() > thr else []
+        spans.sort(); out = []
+        for s in spans:
+            if out and s[0] - out[-1][1] <= dc.get("gap", 0):
+                out[-1][1] = max(out[-1][1], s[1])
+            else:
+                out.append(list(s))
+        return [dict(start=a, end=b, label=names[0]) for a, b in out if b - a >= dc.get("min_chars", 0)]
+
+    def system_one(self, *, state: Any, questions: dict[str, Any], images: list[Any] | None = None) -> dict[str, Any]:
+        """Choice / Noul / Score questions as d3 (decision adapter on the router question ids), plus questions of type "span"."""
+        span_q = {k: q for k, q in questions.items() if isinstance(q, dict) and q.get("type") == "span"}
+        rest = {k: q for k, q in questions.items() if k not in span_q}
+        imgs, img_err = None, None
+        if span_q and images:  # decoded once, shared by every span question of the request
+            try:
+                imgs = self.runtime.load_images(images)
+            except ValueError as e:
+                img_err = str(e)
+        if rest:
+            res = self.decide(state, rest, images)
+        else:
+            res = {"model": self.d3.model_name, "answers": {}, "usage": {"input_tokens": 0, "output_tokens": 0}}
+        answers = dict(res["answers"])
+        for k, q in span_q.items():
+            try:
+                if img_err is not None:
+                    raise ValueError(img_err)
+                answers[k] = self.span_answer(state, q, imgs)
+            except ValueError as e:
+                answers[k] = {"type": "span", "error": "invalid_question", "message": str(e)}
+        res["answers"] = {k: answers[k] for k in questions}
+        res["model"] = "vllm-sr/" + (self.vela3_config.get("size") or {}).get("name", "Vela-3.0-4B")  # X8: the size name
+        return res
+
+    def forward(self, state=None, questions=None, images=None):
+        return self.system_one(state=state, questions=questions, images=images)
+
+    def train(self, mode: bool = True):
+        if mode:
+            raise RuntimeError("inference only")
+        return super().train(False)

ner_head.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc710bdeb492c51564600ff09b645bce2b716d1fff76e810249b0926dd2e49fe
+size 17911004

ner_lora.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3272c03b55df4927aa733a2b5dc45af1b4474cf2034924b6a8c45a084513b9a7
+size 721975664

relation_head.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8bf595b1d23ea1f6d7dc6f751322dad6ed81b86bf2f0c9669d169aec24013cc2
+size 17911004

relation_lora.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:180701270272b6ad94e1048027e026c15cddab85da9e7a32c7491ed94ad5e87f
+size 240668976

router_questions.json

@@ -0,0 +1,220 @@
+{
+ "about": "The decision adapter switches on by question id only. These are the exact questions (instructions + criteria) it was trained on; other wording under the same id also gets the adapter.",
+ "question_ids": [
+  "attack",
+  "domain",
+  "factcheck",
+  "feedback",
+  "intent",
+  "modality",
+  "p_harm",
+  "r_harm",
+  "r_refusal",
+  "scenario"
+ ],
+ "trained_questions": {
+  "domain": {
+   "question": {
+    "type": "choice",
+    "instructions": "Which subject area is this request about?",
+    "criteria": {
+     "biology": "living organisms, anatomy, genetics, medical genetics or viruses",
+     "business": "management, marketing, accounting, business ethics or public relations",
+     "chemistry": "chemical substances, reactions, elements or laboratory chemistry",
+     "computer science": "programming, algorithms, computer systems, security or machine learning",
+     "economics": "markets, macroeconomics, microeconomics or econometrics",
+     "engineering": "electrical or other engineering design and systems",
+     "health": "medicine, clinical practice, nutrition, ageing or sexual health",
+     "history": "past events, periods and historical societies",
+     "law": "legal rules, jurisprudence, courts or international law",
+     "math": "arithmetic, algebra, geometry, statistics or other mathematics",
+     "other": "a subject that fits none of the listed areas",
+     "philosophy": "philosophy, ethics, moral questions or formal logic",
+     "physics": "physical laws, mechanics, astronomy or physical phenomena",
+     "psychology": "mind, behaviour, mental processes or psychological practice",
+     "religion": "religions, religious texts, beliefs, practices and theology"
+    }
+   },
+   "state": "text"
+  },
+  "factcheck": {
+   "question": {
+    "type": "choice",
+    "instructions": "Does answering this request require checking facts?",
+    "criteria": {
+     "NO_FACT_CHECK_NEEDED": "the request can be handled without verifying facts about the world, e.g. translating, rewriting, formatting or writing fiction",
+     "FACT_CHECK_NEEDED": "answering the request relies on factual claims about the world that should be verified"
+    }
+   },
+   "state": "text"
+  },
+  "modality": {
+   "question": {
+    "type": "choice",
+    "instructions": "What kind of output does this request ask for?",
+    "criteria": {
+     "AR": "a text answer only, including code, analysis or describing an existing image",
+     "DIFFUSION": "a newly generated image only",
+     "BOTH": "a newly generated image together with a separate written explanation"
+    }
+   },
+   "state": "text"
+  },
+  "feedback": {
+   "question": {
+    "type": "choice",
+    "instructions": "What feedback does this user turn give about the previous answer?",
+    "criteria": {
+     "SAT": "the user is satisfied with the previous answer",
+     "NEED_CLARIFICATION": "the user asks for clarification or a more detailed explanation",
+     "WRONG_ANSWER": "the user says the previous answer was wrong or did not work",
+     "WANT_DIFFERENT": "the user wants a different answer, format, style or approach",
+     "NO_FEEDBACK": "the user turn gives no feedback on the previous answer: it continues the conversation, adds details or starts a new request"
+    }
+   },
+   "state": "text"
+  },
+  "p_harm": {
+   "question": {
+    "type": "choice",
+    "instructions": "Is this request harmful?",
+    "criteria": {
+     "safe": "a benign request that does not violate any safety policy",
+     "unsafe": "a request that violates a safety policy or seeks harmful assistance"
+    }
+   },
+   "state": "text"
+  },
+  "r_harm": {
+   "question": {
+    "type": "choice",
+    "instructions": "Is this answer harmful?",
+    "criteria": {
+     "safe response": "an assistant answer that is itself harmless",
+     "unsafe response": "an assistant answer that is itself harmful, or that supplies the harmful assistance asked for"
+    }
+   },
+   "state": "parts: user, answer"
+  },
+  "r_refusal": {
+   "question": {
+    "type": "choice",
+    "instructions": "Did the assistant refuse?",
+    "criteria": {
+     "compliance": "an assistant answer that complies with the request and attempts the task",
+     "refusal": "an assistant answer that declines the request or refuses to help"
+    }
+   },
+   "state": "parts: user, answer"
+  },
+  "attack": {
+   "question": {
+    "type": "choice",
+    "instructions": "Is this a prompt injection or jailbreak attempt?",
+    "criteria": {
+     "benign": "a normal request or quoted content that does not try to override system instructions or bypass safety rules",
+     "jailbreak": "a prompt injection or jailbreak that attempts to override system instructions, hijack the task, or bypass safety rules"
+    }
+   },
+   "state": "text"
+  },
+  "scenario": {
+   "question": {
+    "type": "choice",
+    "instructions": "Which scenario does this request belong to?",
+    "criteria": {
+     "alarm": "setting, checking or removing alarms",
+     "audio": "device volume and audio settings",
+     "calendar": "calendar events, meetings and reminders",
+     "datetime": "the current date or time, and time-zone conversion",
+     "email": "reading, sending and managing e-mail and contacts",
+     "general": "greetings, jokes and small talk",
+     "lists": "to-do and shopping lists",
+     "music": "music preferences, information and player settings",
+     "news": "news headlines and updates",
+     "play": "playing music, radio, podcasts, audiobooks or games",
+     "qa": "general knowledge questions, definitions, maths, currency and stocks",
+     "recommendation": "recommendations for events, places or movies",
+     "social": "social media posts and updates",
+     "takeaway": "ordering takeaway food or checking an order",
+     "weather": "weather conditions and forecasts"
+    }
+   },
+   "state": "text",
+   "source": "MASSIVE (en)"
+  },
+  "intent": {
+   "MASSIVE": {
+    "question": {
+     "type": "choice",
+     "instructions": "What does the user want the assistant to do?",
+     "criteria": {
+      "alarm_query": "check which alarms are set",
+      "alarm_remove": "remove or cancel an alarm",
+      "alarm_set": "set an alarm for a time",
+      "audio_volume_down": "turn the volume down",
+      "audio_volume_mute": "mute the audio or make the device quiet",
+      "audio_volume_other": "change another audio setting",
+      "audio_volume_up": "turn the volume up",
+      "calendar_query": "ask about calendar events or reminders",
+      "calendar_remove": "delete a calendar event or reminder",
+      "calendar_set": "add a calendar event or reminder",
+      "datetime_convert": "convert a time between time zones",
+      "datetime_query": "ask for the current date or time",
+      "email_addcontact": "add an e-mail contact",
+      "email_query": "check or read e-mails",
+      "email_querycontact": "ask for a contact's details",
+      "email_sendemail": "send or reply to an e-mail",
+      "general_greet": "greet the assistant",
+      "general_joke": "ask for a joke",
+      "general_quirky": "chit-chat or an unusual request outside the other intents",
+      "lists_createoradd": "create a list or add an item to a list",
+      "lists_query": "ask what is on a list",
+      "lists_remove": "remove a list or an item from a list",
+      "music_dislikeness": "say the user dislikes a song or artist",
+      "music_likeness": "say the user likes a song or artist",
+      "music_query": "ask about the music that is playing",
+      "music_settings": "change music player settings such as shuffle or repeat",
+      "news_query": "ask for news",
+      "play_audiobook": "play or resume an audiobook",
+      "play_game": "start a game",
+      "play_music": "play a song, artist or playlist",
+      "play_podcasts": "play a podcast",
+      "play_radio": "play a radio station",
+      "qa_currency": "ask about currency exchange rates",
+      "qa_definition": "ask for the definition of a word",
+      "qa_factoid": "ask a factual general-knowledge question",
+      "qa_maths": "ask a maths question",
+      "qa_stock": "ask about stock prices",
+      "recommendation_events": "ask for events to go to",
+      "recommendation_locations": "ask for places such as shops or restaurants nearby",
+      "recommendation_movies": "ask for movie recommendations",
+      "social_post": "post on social media or send a complaint to a company",
+      "social_query": "check social media updates",
+      "takeaway_order": "order takeaway food",
+      "takeaway_query": "ask about a takeaway order or restaurant delivery",
+      "weather_query": "ask about the weather"
+     }
+    },
+    "state": "text",
+    "source": "MASSIVE (en)"
+   },
+   "SGD": {
+    "question": {
+     "type": "choice",
+     "instructions": "Using the dialogue history and service schema in state, choose the active intent for this service. Choose NONE when no service intent is active. Do not use future turns or hidden labels.",
+     "criteria": "{<intent>: <intent> for each intent of the service schema} + {NONE: NONE}"
+    },
+    "state": "object: history [{speaker, utterance}], service, schema (the SGD service schema JSON), task: 'SGD current-service intent'"
+   }
+  }
+ },
+ "contract_maps": {
+  "domain": {
+   "router-signal-suite": {
+    "religion": "philosophy"
+   }
+  },
+  "note": "the 14-option domain / 4-option feedback questions of the previous release are still trained and answered"
+ }
+}

span_decode_v2.py

@@ -0,0 +1,272 @@
+"""Word-aware span decoding for the schema encoder's sigmoid span head (PII long-doc fix, 26 Sep).
+
+The v1 decoder (span_data.decode) thresholds every token x label independently and turns each above-threshold
+run into a span. With sub-word tokens (the Vela tokenizer splits digits one by one) a single below-threshold
+piece fragments one entity into several false positives ('ois', '0', 'example'), and every label is decoded
+separately, so overlapping labels each cost a false positive.
+
+decode_v2(probs, offs, names, text, thr, ...) -> [dict(start, end, label)] (code-point offsets)
+  1. label resolution: each token takes its argmax label if that probability > thr, else O
+     (overlapping labels resolved by max score; upstream Vela PII argmax-BIO likewise gives one label per token).
+  2. word units from the text (GLiNER2 word splitter, see _UNIT): URL | run of letters/digits/@._-+ | any other
+     single non-space char; every CJK / kana / hangul / full-width character is its own unit (character level).
+     A token belongs to the unit that holds its first non-space character.
+  3. within a unit, one label: the label with the largest summed probability over the unit's labelled tokens
+     wins and the other labelled tokens of the unit are relabelled to it.
+  4. fill: unlabelled tokens BETWEEN two tokens of the same label inside one unit take that label;
+     extension (extend="unit", default): to the outermost letter/digit tokens of the unit, through inner
+     punctuation ('ois' -> 'lois123@x.example.org'), never onto a bare edge '[' / ']' / '.';
+     extend="alnum": only through directly adjacent letter/digit tokens; extend=False: off.
+  5. contiguous tokens of one label form a span (never joins different labels: upstream decode_entities rule);
+     whitespace is trimmed (upstream), and so are enclosing bracket / quote characters at the span edges.
+  6. optional: bridge=True joins two same-label spans separated by one unit whose probability for that
+     label is > thr * bridge_frac; min_chars={label: n} drops shorter spans.
+Upstream semantics kept: exact code-point spans, whitespace trim, different types never joined. Not
+reproducible from a sigmoid head: the B- tag that splits two adjacent same-type entities (it has no B/I).
+"""
+import re
+import numpy as np
+
+_CJK = ("⺀-⿿　-〿぀-ヿ㄀-ㇿ㐀-䶿一-鿿ꀀ-꓏"
+        "가-힯豈-﫿︰-﹏＀-￯")
+# Word units = GLiNER2's splitters (gliner2/processing/word_splitter.py, Apache-2.0): WhitespaceTokenSplitter's URL
+# rule, CharLevelSplitter's [A-Za-z0-9@._\-+]+ runs (e-mails, IPs, phones, IDs stay one word), widened to Unicode
+# letters/digits (Straße, título), and every CJK / kana / hangul / full-width character on its own (char level).
+_UNIT = re.compile(rf"(?:https?://|www\.)[^\s\]\)\}}>「」『』\"'“”{_CJK}]+"
+                   rf"|(?:(?![{_CJK}])[^\W_]|[@._\-+])+"
+                   rf"|\S")
+_ALNUM = re.compile(r"[^\W_]")
+EDGE = set("[](){}<>「」『』【】《》〈〉\"'“”‘’«»‹›")
+
+
+def units(text):
+    """char index -> unit id (-1 for whitespace)."""
+    u = np.full(len(text) + 1, -1, dtype=np.int64)
+    for k, m in enumerate(_UNIT.finditer(text)):
+        u[m.start():m.end()] = k
+    return u
+
+
+def _first_nonspace(text, a, b):
+    while a < b and text[a].isspace():
+        a += 1
+    return a
+
+
+def trim(text, s, e):
+    while s < e and (text[s].isspace() or text[s] in EDGE):
+        s += 1
+    while e > s and (text[e - 1].isspace() or text[e - 1] in EDGE):
+        e -= 1
+    return s, e
+
+
+def decode_v2(probs, offs, names, text, thr, fill=True, extend="unit", unit_vote=True, trim_edges=True,
+              bridge=False, bridge_frac=0.5, min_chars=None, u=None):
+    probs = np.asarray(probs, dtype=np.float32); offs = np.asarray(offs)
+    T = len(offs)
+    if T == 0:
+        return []
+    valid = offs[:, 1] > offs[:, 0]
+    k = probs.argmax(1); pk = probs[np.arange(T), k]
+    lab = np.where(valid & (pk > thr), k, -1)
+    u = units(text) if u is None else u
+    tu = np.full(T, -1, dtype=np.int64)
+    alnum = np.zeros(T, dtype=bool)
+    for t in range(T):
+        if not valid[t]:
+            continue
+        a, b = int(offs[t, 0]), int(offs[t, 1])
+        f = _first_nonspace(text, a, b)
+        tu[t] = u[f] if f < b and f < len(text) else -1
+        alnum[t] = bool(_ALNUM.search(text[a:b]))
+    # group tokens by unit (tokens are in text order, units contiguous)
+    if unit_vote or fill or extend:
+        t = 0
+        while t < T:
+            if tu[t] < 0:
+                t += 1; continue
+            t2 = t
+            while t2 + 1 < T and (tu[t2 + 1] == tu[t] or not valid[t2 + 1]):
+                t2 += 1
+            idx = [i for i in range(t, t2 + 1) if valid[i]]
+            L = [i for i in idx if lab[i] >= 0]
+            if L:
+                if unit_vote and len({int(lab[i]) for i in L}) > 1:
+                    sc = {}
+                    for i in L:
+                        sc[int(lab[i])] = sc.get(int(lab[i]), 0.0) + float(pk[i])
+                    w = max(sc, key=sc.get)
+                    for i in L:
+                        lab[i] = w
+                if fill:
+                    for c in set(int(lab[i]) for i in L):
+                        pos = [i for i in L if lab[i] == c]
+                        for i in idx:
+                            if pos[0] < i < pos[-1] and lab[i] < 0:
+                                lab[i] = c
+                if extend:
+                    for c in set(int(lab[i]) for i in idx if lab[i] >= 0):
+                        pos = [idx.index(i) for i in idx if lab[i] == c]
+                        if extend == "unit":   # to the outermost letter/digit tokens of the unit, through inner punctuation
+                            an = [j for j, i in enumerate(idx) if alnum[i]]
+                            lo, hi = min([pos[0]] + an[:1]), max([pos[-1]] + an[-1:])
+                            if all(lab[idx[j]] < 0 or lab[idx[j]] == c for j in range(lo, hi + 1)):
+                                for j in range(lo, hi + 1):
+                                    lab[idx[j]] = c
+                        else:                  # "alnum": only through adjacent letter/digit tokens
+                            j = pos[0] - 1
+                            while j >= 0 and lab[idx[j]] < 0 and alnum[idx[j]]:
+                                lab[idx[j]] = c; j -= 1
+                            j = pos[-1] + 1
+                            while j < len(idx) and lab[idx[j]] < 0 and alnum[idx[j]]:
+                                lab[idx[j]] = c; j += 1
+            t = t2 + 1
+    # contiguous runs of one label (skipping zero-width tokens)
+    spans = []
+    cur = None
+    for t in range(T):
+        if not valid[t]:
+            continue
+        c = int(lab[t])
+        if cur is not None and c == cur[0]:
+            cur[2] = int(offs[t, 1]); cur[3].append(t); continue
+        if cur is not None:
+            spans.append(cur)
+        cur = [c, int(offs[t, 0]), int(offs[t, 1]), [t]] if c >= 0 else None
+    if cur is not None:
+        spans.append(cur)
+    if bridge and len(spans) > 1:
+        out = [spans[0]]
+        for sp in spans[1:]:
+            pv = out[-1]
+            if sp[0] == pv[0]:
+                gap = [t for t in range(pv[3][-1] + 1, sp[3][0]) if valid[t]]
+                gu = {int(tu[t]) for t in gap if tu[t] >= 0}
+                if gap and len(gu) <= 1 and all(probs[t, sp[0]] > thr * bridge_frac for t in gap if tu[t] >= 0):
+                    pv[2] = sp[2]; pv[3] = pv[3] + gap + sp[3]; continue
+            out.append(sp)
+        spans = out
+    res = []
+    for c, s, e, _ in spans:
+        s, e = trim(text, s, e) if trim_edges else trim_ws(text, s, e)
+        if e <= s:
+            continue
+        if min_chars and e - s < min_chars.get(names[c], 0):
+            continue
+        res.append(dict(start=s, end=e, label=names[c]))
+    return res
+
+
+def trim_ws(text, s, e):
+    while s < e and text[s].isspace():
+        s += 1
+    while e > s and text[e - 1].isspace():
+        e -= 1
+    return s, e
+
+
+def decode_v1_trimmed(probs, offs, names, text, thr):
+    """The scorer's current rule (span_data.decode + whitespace trim), for before/after tables."""
+    from span_data import decode
+    out = []
+    for s in decode(probs, offs, names, thr):
+        a, b = trim_ws(text, s["start"], s["end"])
+        if b > a:
+            out.append(dict(start=a, end=b, label=s["label"]))
+    return out
+
+
+# ---------------------------------------------------------------------------------------------------------------
+# row-level API (rows = dicts with text, spans [{start,end,label}], names, offs, probs; see dump_span_probs_v2.py)
+# ---------------------------------------------------------------------------------------------------------------
+GRID = [round(x, 2) for x in np.arange(0.05, 0.96, 0.05)]
+DECODERS = {
+    "v1": lambda r, thr: decode_v1_trimmed(r["probs"], r["offs"], r["names"], r["text"], thr),
+    "v2": lambda r, thr: decode_v2(r["probs"], r["offs"], r["names"], r["text"], thr),
+    "v2_noext": lambda r, thr: decode_v2(r["probs"], r["offs"], r["names"], r["text"], thr, extend=False),
+    "v2_alnum": lambda r, thr: decode_v2(r["probs"], r["offs"], r["names"], r["text"], thr, extend="alnum"),
+    "v2_notrim": lambda r, thr: decode_v2(r["probs"], r["offs"], r["names"], r["text"], thr, trim_edges=False),
+    "v2_bridge": lambda r, thr: decode_v2(r["probs"], r["offs"], r["names"], r["text"], thr, bridge=True),
+    "v2_argmax_only": lambda r, thr: decode_v2(r["probs"], r["offs"], r["names"], r["text"], thr, fill=False,
+                                               extend=False, unit_vote=False, trim_edges=False),
+}
+
+
+def decode_rows(rows, thr, decoder="v2"):
+    f = DECODERS[decoder] if isinstance(decoder, str) else decoder
+    return [f(r, thr) for r in rows]
+
+
+def _psd(span_data_path):
+    """Load the upstream semantic-router span_data.py (src/training/model_classifier/pii_model_fine_tuning_lora/span_data.py)
+    from span_data_path. Eval helper only (dev threshold picks); inference never calls it."""
+    import importlib.util
+    from pathlib import Path
+    if span_data_path is None:
+        raise ValueError("pii_metrics needs span_data_path: the path of the upstream span_data.py")
+    spec = importlib.util.spec_from_file_location("pii_span_data_up", Path(span_data_path))
+    m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
+    return m
+
+
+PII_TYPES = ["AGE", "CREDIT_CARD", "DATE_TIME", "DOMAIN_NAME", "EMAIL_ADDRESS", "GPE", "IBAN_CODE", "IP_ADDRESS", "NRP",
+             "ORGANIZATION", "PERSON", "PHONE_NUMBER", "STREET_ADDRESS", "TITLE", "US_DRIVER_LICENSE", "US_SSN", "ZIP_CODE"]
+
+
+def pii_metrics(rows, preds, span_data_path):
+    """Upstream Vela PII exact-entity metric (span_data.entity_metrics, whitespace-trimmed gold); span_data_path: see _psd."""
+    P = _psd(span_data_path)
+    recs = [dict(full_text=r["text"], spans=[dict(start_position=s["start"], end_position=s["end"], entity_type=s["label"],
+                 entity_value=r["text"][s["start"]:s["end"]]) for s in r["spans"]]) for r in rows]
+    return P.entity_metrics(recs, [{(s["label"], s["start"], s["end"]) for s in p} for p in preds], PII_TYPES)
+
+
+def toxic_score(rows, preds):
+    from span_data import char_f1
+    return float(np.mean([char_f1(p, r["spans"]) for r, p in zip(rows, preds)]))
+
+
+def halu_metrics(rows, preds):
+    from train_schema_span import ragtruth_metrics_spans
+    return ragtruth_metrics_spans([dict(text=r["text"], spans=r["spans"]) for r in rows], preds)
+
+
+def family_objective(family, span_data_path=None):
+    """Dev objective per span label family (what the threshold is chosen to maximise); span_data_path: PII only (see _psd)."""
+    if family == "pii":
+        return lambda rows, preds: pii_metrics(rows, preds, span_data_path)["micro"]["f1"]
+    if family == "toxic":
+        return toxic_score
+    if family == "halu":
+        return lambda rows, preds: halu_metrics(rows, preds)["example_f1"]
+    raise KeyError(family)
+
+
+def pick_threshold(dev_sets, family, decoder="v2", grid=GRID, span_data_path=None):
+    """Choose one threshold per label family on DEV rows only.
+    dev_sets: list of row lists; the objective is the unweighted mean over the sets (for PII: dev short, dev 4096,
+    dev 8192 -> upstream's length-macro selection, so the dense long rows cannot dominate). Returns (thr, curve)."""
+    obj = family_objective(family, span_data_path)
+    curve = {t: float(np.mean([obj(rows, decode_rows(rows, t, decoder)) for rows in dev_sets])) for t in grid}
+    best = max(curve.values())
+    thr = min(t for t, v in curve.items() if v >= best - 1e-12)  # ties -> lowest threshold
+    return thr, curve
+
+
+if __name__ == "__main__":  # self-test on the fragment cases seen in run C
+    text = "Le formulaire indique [pavel_200015@summit15.example.org] dans adresse courriel."
+    names = ["EMAIL_ADDRESS", "PERSON"]
+    import unicodedata  # noqa
+    # fake token offsets: split at every non-alnum boundary
+    offs = [(m.start(), m.end()) for m in re.finditer(r"\s?\w+|\s?[^\w\s]", text)]
+    p = np.zeros((len(offs), 2), dtype=np.float32)
+    s0 = text.index("pavel"); e0 = text.index("]")
+    for i, (a, b) in enumerate(offs):
+        if a >= s0 - 1 and b <= e0 + 1:
+            p[i, 0] = 0.9 if i % 3 else 0.2        # fragmented
+    p[[i for i, (a, b) in enumerate(offs) if text[a:b].strip() == "["][0], 0] = 0.8  # bracket above threshold
+    out = decode_v2(p, np.array(offs), names, text, 0.5)
+    assert [(o["label"], text[o["start"]:o["end"]]) for o in out] == [("EMAIL_ADDRESS", "pavel_200015@summit15.example.org")], out
+    t2 = "表格在日期一栏填写了「2015-06-06」。"
+    print(units(t2)[:14], "ok")

span_head.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5e74fe176bfd580f86448a152c7a8e9d278645baaf155e5f2f0ee3b766c8a61
+size 17910964

span_lora.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1c684f81bd9f4d9d2c749120162f26482a9e05984ca8865652a5ec3c18a109d
+size 240668936

vela3_adapters.py

@@ -0,0 +1,87 @@
+"""Gated LoRA adapters of Vela 3.0.
+
+The adapters (vela3_config.json "adapters") sit on the base's Linear layers; each adapter's layers, rank and alpha come from its
+*_lora.safetensors. At most one adapter is on in any forward; with no adapter active, a wrapped layer returns base(x) itself, so every
+other pass is the untouched base computation.
+
+The adapter math is the training code's GatedLoRA in eval mode (dropout off):
+    y = base(x) + ((x.float() @ A.T) @ B.T * alpha / r).to(y.dtype)
+A row mask applies the adapter to some rows of a batch only: torch.where keeps base(x) bit for bit on the other rows."""
+from __future__ import annotations
+
+import contextlib
+import json
+
+import torch
+from torch import nn
+
+
+class _Gate:
+    name = None   # active adapter name, or None (all adapters off)
+    rows = None   # None = every row of the batch; else a bool tensor [B]
+
+
+GATE = _Gate()
+
+
+@contextlib.contextmanager
+def active(name, rows=None):
+    """Activate one adapter for the forwards inside the block (rows: optional bool mask over the batch)."""
+    prev = (GATE.name, GATE.rows)
+    GATE.name, GATE.rows = name, rows
+    try:
+        yield
+    finally:
+        GATE.name, GATE.rows = prev
+
+
+class MultiLoRA(nn.Module):
+    def __init__(self, base: nn.Linear):
+        super().__init__()
+        self.base = base
+        self.ad = {}  # name -> (A [r, in] fp32, B [out, r] fp32, scale)
+
+    def add(self, name, A, B, scale):
+        dev = self.base.weight.device
+        self.ad[name] = (A.to(dev, torch.float32), B.to(dev, torch.float32), float(scale))
+
+    def forward(self, x):
+        y = self.base(x)
+        name = GATE.name
+        if name is None or name not in self.ad:
+            return y
+        A, B, s = self.ad[name]
+        d = ((x.float() @ A.T) @ B.T * s).to(y.dtype)
+        rows = GATE.rows
+        if rows is None:
+            return y + d
+        if rows.shape[0] != y.shape[0]:
+            raise RuntimeError("row gate does not match the batch")
+        return torch.where(rows.view(-1, *([1] * (y.dim() - 1))), y + d, y)
+
+
+def attach(lm, name, path):
+    """Attach the adapter in `path` (safetensors: '<module path>.A' / '.B', metadata r / alpha / first / targets) to the text model."""
+    from safetensors import safe_open
+    with safe_open(str(path), framework="pt") as f:
+        meta = f.metadata() or {}
+        sd = {k: f.get_tensor(k) for k in f.keys()}
+    r, alpha = int(meta["r"]), int(meta["alpha"])
+    mods = sorted({k.rsplit(".", 1)[0] for k in sd})
+    for mp in mods:
+        parent_path, attr = mp.rsplit(".", 1)
+        parent = lm.get_submodule(parent_path)
+        cur = getattr(parent, attr)
+        if isinstance(cur, nn.Linear):
+            cur = MultiLoRA(cur)
+            setattr(parent, attr, cur)
+        elif not isinstance(cur, MultiLoRA):
+            raise ValueError(f"{mp} is not a Linear layer")
+        A, B = sd[mp + ".A"], sd[mp + ".B"]
+        if A.shape != (r, cur.base.in_features) or B.shape != (cur.base.out_features, r):
+            raise ValueError(f"adapter shape mismatch at {mp}")
+        cur.add(name, A, B, alpha / r)
+    if len(sd) != 2 * len(mods):
+        raise ValueError(f"adapter {name}: unpaired A / B tensors")
+    return dict(modules=len(mods), r=r, alpha=alpha, first=int(meta.get("first", -1)),
+                targets=json.loads(meta.get("targets", "[]")))

vela3_config.json

@@ -0,0 +1,307 @@
+{
+ "format": "vela3/3",
+ "base": {
+  "repo_id": "vllm-sr/d3-flash",
+  "revision": "8b35c853b90e777595ec36bacae820fe08ea077a",
+  "runtime_note": "verified on this base revision's own runtime (d3 v3.1 *.py) with vela3_span.text_states / image_states (span passes through rt.encoder, noncausal as in training; FINISH_C.md 'Runtime v3.1 span fix')"
+ },
+ "adapters": {
+  "span": {
+   "file": "span_lora.safetensors",
+   "r": 48,
+   "alpha": 48,
+   "first_layer": 16,
+   "modules": 100,
+   "switched_on": "span passes of relation / evidence / answer questions and the router label sets (span.ner.route)",
+   "source": "Vela 3.0 flash R4 span LoRA, ckpt-005000 (round 2, r4 --mix r6s (Phase B pools) --granfix + wordings, 24,000 steps; dev pick)"
+  },
+  "decision": {
+   "file": "decision_lora.safetensors",
+   "r": 24,
+   "alpha": 24,
+   "first_layer": 0,
+   "modules": 200,
+   "switched_on": "the rows of router_question_ids in a decision pass",
+   "source": "Vela 3.0 flash decision LoRA, ckpt-003000 (--carve --sgd --dna, 3,000 steps; picked on the held-out sel carve)"
+  },
+  "ner": {
+   "file": "ner_lora.safetensors",
+   "r": 96,
+   "alpha": 96,
+   "first_layer": 8,
+   "modules": 150,
+   "switched_on": "span passes of open-label entity questions (span.ner.route)",
+   "source": "Vela 3.0 flash N5 NER span LoRA, ckpt-006000 (round 2, n5 --mix n5b --ner-wordings-only, 24,000 steps; reviewed checkpoint (approved; the rule's pick was ckpt-006000))"
+  },
+  "relation": {
+   "file": "relation_lora.safetensors",
+   "r": 48,
+   "alpha": 48,
+   "first_layer": 16,
+   "modules": 100,
+   "switched_on": "span passes of relation questions only (modeling_vela3._span_route relation rule: 'Which spans are the <relation> of <head>?', 'Which spans are related to <head> by these relations?', ...)",
+   "source": "Vela 3.0 flash R5S span LoRA, ckpt-008000 (8,000-step R5S recipe from this package's R4 ckpt-005000, r6s base mix + DocRED / CrossRE / FewRel train splits; relation questions only)"
+  },
+  "image_halu": {
+   "file": "image_halu_lora.safetensors",
+   "r": 48,
+   "alpha": 48,
+   "first_layer": 16,
+   "modules": 100,
+   "switched_on": "span passes of halu label sets asked with images (span.image_halu)",
+   "source": "Vela 3.0 flash MM2 image-halu span LoRA, ckpt-001500 (from this package's R4 + the R5 image rows; dev pick on the M-HalDetect train-side check items)"
+  },
+  "decision_df": {
+   "file": "decision_df_lora.safetensors",
+   "r": 24,
+   "alpha": 24,
+   "first_layer": 0,
+   "modules": 200,
+   "switched_on": "the rows of the domain and feedback router ids, in their own pass",
+   "source": "df_flash/ckpt-002000 (init = this package's decision LoRA, Vela 2.0 router data + router-signal-suite train domain / feedback, decontaminated)"
+  }
+ },
+ "router_question_ids": [
+  "attack",
+  "domain",
+  "factcheck",
+  "feedback",
+  "intent",
+  "modality",
+  "p_harm",
+  "r_harm",
+  "r_refusal",
+  "scenario"
+ ],
+ "router_questions_file": "router_questions.json",
+ "span": {
+  "head_file": "span_head.safetensors",
+  "read": "final-norm states (last_hidden_state)",
+  "threshold": 0.6,
+  "thresholds_by_set": {
+   "halu": 0.5,
+   "toxic": 0.4
+  },
+  "pii_buckets": [
+   {
+    "name": "short",
+    "max_tokens": 1024,
+    "threshold": 0.55
+   },
+   {
+    "name": "4K",
+    "max_tokens": 6144,
+    "threshold": 0.7
+   },
+   {
+    "name": "8K",
+    "max_tokens": 1000000000000,
+    "threshold": 0.7
+   }
+  ],
+  "threshold_sources": {
+   "open": "R4 pick (diag04b-fam: forced checkpoint (every candidate is read)): ckpt-005000 / final, definitions 0.6, names-only 0.6",
+   "halu_pii_toxic": "NB-dev router-span reads of R4 at the pick (results/r4_spanread.json): halu, PII short / 4K / 8K, toxic dev carve",
+   "evidence": "evidence_pick.json: sent gap 0 min chars 0 at 0.5, mean thr-half word F1 over ACL silver validation + RAGBench verbatim dev",
+   "ner": "N5 ckpt-006000 head final (dev pick: mode defs, eval-half F1 0.7434); thresholds: that checkpoint's ner_shift thr-half picks (definitions 0.6, names only 0.65); mode: definitions, as the 4B",
+   "names_only": "open labels asked names only run on the NER adapter (option B) at span.ner.threshold_names_only 0.65, that checkpoint's ner_shift names thr-half pick"
+  },
+  "router_label_sets": {
+   "pii": [
+    "AGE",
+    "CREDIT_CARD",
+    "DATE_TIME",
+    "DOMAIN_NAME",
+    "EMAIL_ADDRESS",
+    "GPE",
+    "IBAN_CODE",
+    "IP_ADDRESS",
+    "NRP",
+    "ORGANIZATION",
+    "PERSON",
+    "PHONE_NUMBER",
+    "STREET_ADDRESS",
+    "TITLE",
+    "US_DRIVER_LICENSE",
+    "US_SSN",
+    "ZIP_CODE"
+   ],
+   "halu": [
+    "unsupported"
+   ],
+   "toxic": [
+    "Criminal Planning/Confessions",
+    "Violence",
+    "Hate/Identity Hate",
+    "Harassment",
+    "Profanity",
+    "Sexual",
+    "Sexual (minor)",
+    "Controlled/Regulated Substances",
+    "PII/Privacy",
+    "Guns and Illegal Weapons",
+    "Suicide and Self Harm",
+    "Unauthorized Advice",
+    "Political/Misinformation/Conspiracy",
+    "Fraud/Deception",
+    "Illegal Activity",
+    "Threat",
+    "Copyright/Trademark/Plagiarism",
+    "High Risk Gov Decision Making",
+    "Immoral/Unethical",
+    "Needs Caution",
+    "Other",
+    "S1",
+    "S2",
+    "S3",
+    "S4",
+    "S5",
+    "S6",
+    "S7",
+    "S8",
+    "S9",
+    "S10",
+    "S11",
+    "S12",
+    "S14",
+    "others",
+    "social_stereotypes_and_unfair_discrimination",
+    "disseminating_false_or_misleading_information_encouraging_disinformation_campaigns",
+    "violence_and_physical_harm",
+    "private_information_individual",
+    "sensitive_information_organization_government",
+    "defamation_encouraging_unethical_or_unsafe_actions",
+    "toxic_language_hate_speech",
+    "fraud_assisting_illegal_activities",
+    "copyright_violations",
+    "causing_material_harm_by_disseminating_misinformation",
+    "sexual_content",
+    "mental_health_over-reliance_crisis"
+   ]
+  },
+  "schemas": {
+   "pii": {
+    "question": "Which spans are personal information?",
+    "labels": {
+     "AGE": "a person's age",
+     "CREDIT_CARD": "a payment card number",
+     "DATE_TIME": "a date, time or date of birth",
+     "DOMAIN_NAME": "an internet domain name or website address",
+     "EMAIL_ADDRESS": "an e-mail address",
+     "GPE": "a country, city, state or other geopolitical place",
+     "IBAN_CODE": "an international bank account number (IBAN)",
+     "IP_ADDRESS": "an IPv4 or IPv6 address",
+     "NRP": "a nationality, religious or political group",
+     "ORGANIZATION": "the name of a company, institution or other organisation",
+     "PERSON": "a person's name",
+     "PHONE_NUMBER": "a telephone number",
+     "STREET_ADDRESS": "a street address or postal address",
+     "TITLE": "a personal or professional title such as Dr. or Mrs.",
+     "US_DRIVER_LICENSE": "a US driver's licence number",
+     "US_SSN": "a US social security number",
+     "ZIP_CODE": "a postal or ZIP code"
+    }
+   },
+   "halu": {
+    "question": "Which spans of the answer are not supported by the context?",
+    "labels": {
+     "unsupported": "a claim not supported by the context"
+    }
+   },
+   "evidence": {
+    "question": "Which spans of the context support the answer to the question?",
+    "labels": {
+     "evidence": "a sentence or passage of the context that supports the answer"
+    }
+   }
+  },
+  "default_question": "Which spans are named entities of these types?",
+  "rule": "routing: open-label entity questions run on the NER adapter (span.ner), everything else on the span adapter; on the span adapter, a label set within one router label set (PII types / unsupported / toxic labels) takes that set's threshold (PII by target length) and, for PII and halu, the trained question text and label descriptions where the request leaves them empty; a label set of evidence names (evidence and its training synonyms) takes the evidence threshold and decoding; other open labels take span.threshold. Open labels get d3-mini label definitions by default on both adapters",
+  "threshold_names_only": 0.6,
+  "evidence": {
+   "labels": [
+    "evidence",
+    "supporting evidence",
+    "supporting passage",
+    "relevant text",
+    "citation",
+    "evidence span",
+    "supporting sentence"
+   ],
+   "question": "Which spans of the context support the answer to the question?",
+   "threshold": 0.5,
+   "decode": {
+    "name": "sent",
+    "gap": 0,
+    "min_chars": 0
+   }
+  },
+  "ner": {
+   "head_file": "ner_head.safetensors",
+   "definitions": "auto",
+   "threshold": 0.6,
+   "threshold_names_only": 0.65,
+   "route": "open labels (not a router label set, no evidence / answer label) asked with no instructions, or with instructions that name entities / types / categories and match no relation, answer or evidence pattern -> NER adapter + ner_head; everything else (router label sets PII / halu / toxic, evidence / answer labels, relation questions such as \"Which spans are the <relation> of <head>?\", answer / evidence questions, other wordings) -> span adapter + span_head (modeling_vela3._span_route)",
+   "source": "N5 ckpt-006000 head final (dev pick: mode defs, eval-half F1 0.7434); thresholds: that checkpoint's ner_shift thr-half picks (definitions 0.6, names only 0.65); mode: definitions, as the 4B",
+   "names_only_route": "ner"
+  },
+  "relation": {
+   "head_file": "relation_head.safetensors",
+   "threshold": "one relation asked (head-given): 0.65 (head-conditioned RE dev: CrossRE dev, FewRel dev); several relations at once: 0.8 (end-to-end RE dev: DocRED dev, CrossRE dev); both on the relation adapter",
+   "rule": "relation questions (_span_route relation pattern, no router label set) run on adapters.relation + this head; every other span question routes as before",
+   "source": "R5S ckpt-008000 head_final",
+   "threshold_dev_multi": 0.8,
+   "threshold_dev_pair": 0.65
+  },
+  "image_halu": {
+   "question": "Which spans of the answer are not supported by the image?",
+   "labels": {
+    "unsupported": "a claim not supported by the image"
+   },
+   "threshold": 0.3,
+   "rule": "a halu span question asked with images (system_one images=[...]) takes this question and label description where the request leaves them empty, and this threshold; the images go into the span pass in d3's image layout (one placeholder per image before the user text, the checkpoint's processor)",
+   "source": "MM2 MM2_001500; threshold = max char-F1 on the M-HalDetect TRAIN-side dev (491 items, grid .05-.95); mm2_pick.json",
+   "head_file": "image_halu_head.safetensors"
+  }
+ },
+ "definitions": {
+  "cache_file": "label_definitions.json",
+  "default": {
+   "open labels": "auto",
+   "router label sets": null
+  },
+  "generation": "labels without a description: the d3-flash backbone + the Qwen3.5 lm_head in labeldef_lm_head.safetensors writes a one-line definition (causal, greedy, <= 40 new tokens, first line)",
+  "writer": "grafted_head",
+  "writer_options": "base: the base writes (tied bases only); grafted_head: the backbone + lm_head_file; labeldef_writer: d3-mini@566da0ea (optional download); names: no generation, labels without a cached or given definition run names only. Env VELA3_DEF_WRITER overrides.",
+  "lm_head_file": "labeldef_lm_head.safetensors",
+  "cache_note": "label_definitions.json ships empty (no benchmark label set is cached); definitions for open labels without a description are written at request time by definitions.writer"
+ },
+ "render": "d3 span rendering v2 (vela3_span.py)",
+ "attention": "noncausal_full_attention (d3 as shipped) for decisions and spans; causal for label definitions",
+ "router_gate": "id",
+ "decision_opt_in": false,
+ "size": {
+  "name": "Vela-3.0-9B",
+  "d3": "d3-flash",
+  "x8_package": "final (Phase D: round-2 picks; d3 v3.1 runtime + span fix)"
+ },
+ "x8": {
+  "phase": "D (final)",
+  "picks": {
+   "D": "A",
+   "S": "B",
+   "N": "B",
+   "L": "B"
+  },
+  "decision": "decision LoRA ckpt-003000",
+  "span": "R4 ckpt-005000",
+  "ner": "N5 ckpt-006000",
+  "relation": "R5S ckpt-008000 (relation questions only)",
+  "image_halu": "MM2 MM2_001500 (image halu label sets only)",
+  "decision_optin": "none at this size (opt-in decision LoRA not trained)"
+ },
+ "decision_task_adapters": {
+  "domain": "decision_df",
+  "feedback": "decision_df"
+ }
+}

vela3_labeldef.py

@@ -0,0 +1,144 @@
+"""Label definitions of Vela-3.0-4B.
+
+d3-mini itself, with every adapter off and CAUSAL attention (d3's noncausal mask hook is lifted for the generation), writes a
+one-line definition per label. The prompt and decoding are those of the training-time probe (labeldef.py):
+  user turn only, chat template with enable_thinking=False and the generation prompt;
+  context "The full label set is: a, b, c." when the label set has <= 60 labels, else the bare label;
+  greedy, <= 40 new tokens, first line kept, stripped.
+Each span option is then rendered as `label: definition`. Definitions are cached per label set (in memory), and the file
+label_definitions.json holds the definitions the OOD-7 read used (generated on GPU, batched), keyed by label set."""
+from __future__ import annotations
+
+import contextlib
+import json
+from collections import OrderedDict
+from pathlib import Path
+
+import torch
+
+CTX_MAX = 60
+MAX_NEW = 40
+PROMPT = ("You are writing annotation guidelines for named entity recognition.{ctx}\n"
+          "Define the entity type \"{label}\" in one short sentence: what kind of text span it covers. Reply with the definition only.")
+
+
+def prompt(label, names):
+    ctx = f"\nThe full label set is: {', '.join(names)}." if len(names) <= CTX_MAX else ""
+    return PROMPT.format(ctx=ctx, label=label)
+
+
+@contextlib.contextmanager
+def causal(lm):
+    """Lift d3's noncausal mask pre-hook (named mask_inputs) from the text model for the duration of the block."""
+    hooks = lm._forward_pre_hooks
+    saved = OrderedDict(hooks)
+    for k in [k for k, fn in hooks.items() if getattr(fn, "__name__", "") == "mask_inputs"]:
+        del hooks[k]
+    try:
+        yield
+    finally:
+        hooks.clear(); hooks.update(saved)
+
+
+# X8 option A: definition-writer policy (patch_labeldef2.py)
+class LabelDefiner:
+    def __init__(self, runtime, adapters, cache_file=None, batch=64):
+        self.rt, self.A, self.batch = runtime, adapters, batch
+        self.mem = {}
+        self.gen = None
+        self.def_cfg, self.root = None, None  # X8 option A: definition-writer policy (definitions.* of the package's vela3_config.json)
+        if cache_file:
+            self.root = Path(cache_file).parent; vc = self.root / "vela3_config.json"
+            if vc.exists():
+                self.def_cfg = json.loads(vc.read_text()).get("definitions") or {}
+        if cache_file and Path(cache_file).exists():
+            for e in json.loads(Path(cache_file).read_text())["sets"]:
+                self.mem[self._key(e["labels"])] = dict(e["definitions"])
+
+    @staticmethod
+    def _key(names):
+        names = list(names)
+        return tuple(sorted(names)) if len(names) <= CTX_MAX else None
+
+    def _model(self):
+        """X8 option A: definition-writer policy (vela3_config.json definitions.writer; env VELA3_DEF_WRITER overrides)."""
+        if self.gen is None:
+            import os, warnings
+            from transformers import GenerationConfig
+            from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5ForConditionalGeneration
+            dcfg = self.def_cfg or {}; mode = os.environ.get("VELA3_DEF_WRITER") or dcfg.get("writer", "base")
+            bb = self.rt.backbone; cfg = bb.config; self.tok_w, self.writer = self.rt.tokenizer, mode
+            tied = getattr(cfg, "tie_word_embeddings", None)
+            if tied is None:
+                tied = getattr(getattr(cfg, "text_config", None), "tie_word_embeddings", True)
+            head = None
+            try:
+                if mode == "names":
+                    self.gen = False; return None
+                if mode == "base":
+                    assert tied, "refusing to write definitions with an untied base that has no lm_head"
+                    head = bb.language_model.embed_tokens.weight
+                elif mode == "grafted_head":
+                    from safetensors.torch import load_file
+                    hf = Path(self.root) / dcfg["lm_head_file"]
+                    head = load_file(str(hf))["lm_head.weight"].to(self.rt.device, bb.language_model.embed_tokens.weight.dtype)
+                    assert head.shape == bb.language_model.embed_tokens.weight.shape, (tuple(head.shape), "grafted head does not fit the backbone")
+                elif mode == "labeldef_writer":
+                    w = dcfg["labeldef_writer"]; path = os.environ.get("VELA3_LABELDEF_WRITER")
+                    if not path:
+                        from huggingface_hub import snapshot_download
+                        path = snapshot_download(w["repo_id"], revision=w.get("revision"))
+                    from transformers import AutoTokenizer
+                    from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5Model
+                    bb = Qwen3_5Model.from_pretrained(path, dtype=torch.bfloat16, device_map={"": str(self.rt.device)}).eval(); cfg = bb.config
+                    wt = getattr(cfg, "tie_word_embeddings", None)
+                    wt = getattr(getattr(cfg, "text_config", None), "tie_word_embeddings", True) if wt is None else wt
+                    assert wt, f"definition writer {path} is untied"
+                    head = bb.language_model.embed_tokens.weight; self.tok_w = AutoTokenizer.from_pretrained(path); self.writer = f"labeldef_writer {path}"
+                else:
+                    raise ValueError(f"unknown definitions.writer {mode!r}")
+            except Exception as e:  # names only for uncached labels, never a definition from an untied head
+                warnings.warn(f"vela3_labeldef: no definition writer ({mode}: {type(e).__name__}: {e}); uncached labels run names only")
+                self.gen = False; return None
+            with torch.device("meta"):
+                g = Qwen3_5ForConditionalGeneration(cfg)
+            g.model = bb
+            g.lm_head = torch.nn.Linear(head.shape[1], head.shape[0], bias=False, device="meta")
+            g.lm_head.weight = head if isinstance(head, torch.nn.Parameter) else torch.nn.Parameter(head, requires_grad=False)
+            g.generation_config = GenerationConfig.from_model_config(cfg)
+            g.eval()
+            self.gen = g
+        return self.gen or None
+
+    @torch.no_grad()
+    def generate(self, prompts):
+        g = self._model(); out = []
+        if g is None:
+            return [None] * len(prompts)
+        tok = self.tok_w
+        lm = g.model.language_model
+        for i in range(0, len(prompts), self.batch):
+            bt = prompts[i:i + self.batch]
+            txt = [tok.apply_chat_template([{"role": "user", "content": p}], tokenize=False, add_generation_prompt=True, enable_thinking=False) for p in bt]
+            enc = tok(txt, return_tensors="pt", padding=True, add_special_tokens=False).to(self.rt.device)
+            with self.A.active(None), causal(lm):
+                o = g.generate(**enc, max_new_tokens=MAX_NEW, do_sample=False, pad_token_id=tok.pad_token_id)
+            out += [tok.decode(x, skip_special_tokens=True).strip().split("\n")[0].strip() for x in o[:, enc["input_ids"].shape[1]:]]
+        return out
+
+    def define(self, names, only=None):
+        """{label: definition} for the label set `names` (order as given); `only` restricts which labels are generated."""
+        names = list(names); want = [n for n in names if only is None or n in only]
+        key = self._key(names)
+        got = dict(self.mem.get(key, {})) if key is not None else {n: self.mem.get((None, n)) for n in want if (None, n) in self.mem}
+        miss = [n for n in want if not got.get(n)]
+        if miss:
+            for n, d in zip(miss, self.generate([prompt(n, names) for n in miss])):
+                if d is None:  # no writer under this policy: names only for this label
+                    continue
+                got[n] = d
+                if key is None:
+                    self.mem[(None, n)] = d
+            if key is not None:
+                self.mem[key] = {**self.mem.get(key, {}), **{n: got[n] for n in miss if n in got}}
+        return {n: got.get(n) for n in want}  # X8: a label without a definition runs names only

vela3_span.py

@@ -0,0 +1,232 @@
+"""Span pass of Vela-3.0-4B.
+
+One span question = one forward pass of d3-mini (noncausal full attention, as shipped) with the SPAN LoRA switched on, over d3's
+own prompt: system prompt, then `State:` (the request parts), `Question:` (the span question) and `Options:` (one line per label,
+`<code>: <label>[: <description or definition>]`), through the chat template. The span head (Vela 2.0 SpanHeadV2: word x label
+bilinear + MLP) reads the final-norm states and scores every word of the target part against every label; words above the
+threshold are joined into spans (Vela 2.0 decoder, word units).
+State rendering: one part = its text; several parts = "<role>:\\n<text>" blocks in order, blank-line separated.
+Targets longer than 2,048 tokens are split into word-aligned windows (<= 1,800 tokens, stride 1,536); word logits are averaged.
+This is the training-time eval path (r1_eval.Predictor) at batch 1.
+With images (system_one images=[...]), the images enter the same pass in d3's image layout (SpanEngine._image_logits)."""
+from __future__ import annotations
+
+import contextlib
+import math
+import sys
+import re as _re
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+WIN, STRIDE, RMAX = 1800, 1536, 2048
+
+
+def text_states(rt, ids):
+    """Final-norm states of one unpadded text prompt, as d3 runs a noncausal_full_attention checkpoint (what the adapters
+    were trained on). d3 <= 566da0ea puts a mask pre-hook on the text model, so the plain backbone call is noncausal; d3 v3.1
+    runs such checkpoints through rt.encoder (PromptEncoder) and leaves the stock backbone forward causal."""
+    mask = torch.ones_like(ids)
+    enc = getattr(rt, "encoder", None)
+    if enc is not None:
+        return enc(rt.backbone.get_input_embeddings()(ids), mask)
+    return rt.backbone(input_ids=ids, attention_mask=mask, use_cache=False).last_hidden_state
+
+
+def image_states(rt, inputs):
+    """text_states for an image prompt (processor outputs): v3.1's image embeddings + mRoPE positions through rt.encoder."""
+    enc = getattr(rt, "encoder", None)
+    if enc is not None and hasattr(rt, "image_embeddings"):
+        embeds, mrope = rt.image_embeddings(inputs)
+        return enc(embeds, inputs["attention_mask"], mrope)
+    return rt.backbone(**inputs, use_cache=False).last_hidden_state
+
+
+class SpanHeadV2(nn.Module):
+    def __init__(self, hidden, d=256, slots=64):
+        super().__init__()
+        self.d = d
+        self.wn, self.ln = nn.LayerNorm(hidden), nn.LayerNorm(hidden)
+        self.slot = nn.Embedding(slots, hidden)
+        self.K, self.Q = nn.Linear(hidden, d, bias=False), nn.Linear(hidden, d, bias=False)
+        self.M, self.N = nn.Linear(hidden, d), nn.Linear(hidden, d, bias=False)
+        self.v = nn.Linear(d, 1, bias=False)
+        self.o = nn.Linear(hidden, 1)
+
+    def forward(self, words, labels):
+        with torch.autocast(device_type=words.device.type, enabled=False):
+            w = self.wn(words.float()); w = w - w.mean(0, keepdim=True)
+            L = labels.shape[0]
+            e = self.ln(labels.float()) + self.slot(torch.arange(L, device=labels.device).clamp(max=self.slot.num_embeddings - 1))
+            if L >= 2:
+                e = e - e.mean(0, keepdim=True)
+            k, q = self.K(w), self.Q(e)
+            bil = (k @ q.T) / math.sqrt(self.d)
+            mlp = self.v(F.gelu(self.M(w)[:, None, :] + self.N(e)[None, :, :])).squeeze(-1)
+            return bil + mlp, self.o(w).squeeze(-1), q
+
+
+_CJK = ("⺀-⿿　-〿぀-ヿ㄀-ㇿ㐀-䶿一-鿿ꀀ-꓏"
+        "가-힯豈-﫿︰-﹏＀-￯")
+_TRAIL = ".,;:!?)\\]}>\"'”’»"
+_WORD = _re.compile(rf"""(?:https?://|www\.)[^\s{_CJK}]+?(?=[{_TRAIL}]*(?![^\s{_CJK}]))
+    |[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{{2,}}
+    |@[a-z0-9_]+
+    |[{_CJK}]
+    |[^\W{_CJK}]+(?:[-_][^\W{_CJK}]+)*
+    |\S""", _re.VERBOSE | _re.IGNORECASE)
+
+
+def word_first_tokens(text, offs):
+    w = [(m.start(), m.end()) for m in _WORD.finditer(text)]
+    if not w or offs is None or len(offs) == 0:
+        return np.zeros((0, 2), np.int32), np.zeros(0, np.int32)
+    offs = np.asarray(offs); st, en = offs[:, 0], offs[:, 1]; valid = en > st
+    cummax_end = np.maximum.accumulate(np.where(valid, en, -1)); wo, ft = [], []
+    for a, b in w:
+        t = int(np.searchsorted(cummax_end, a, side="right"))
+        while t < len(offs) and not valid[t]:
+            t += 1
+        if t < len(offs) and st[t] < b:
+            wo.append((a, b)); ft.append(t)
+    return np.asarray(wo, np.int32).reshape(-1, 2), np.asarray(ft, np.int32)
+
+
+def windows(ft, n, win=WIN, stride=STRIDE):
+    starts = sorted(set(int(x) for x in ft))
+    if not starts:
+        return [(0, n)]
+    out, a = [], starts[0]
+    while True:
+        lim = a + win
+        nxt = [s for s in starts if s > a and s < lim]
+        b = n if lim >= n else (max(s for s in starts if s < lim and s > a) if nxt else min(n, lim))
+        out.append((a, b))
+        if b >= n:
+            break
+        cand = [s for s in starts if s >= a + stride and s < b]
+        a = cand[0] if cand else b
+    return out
+
+
+class Render:
+    def __init__(self, tok, d3_format):
+        self.tok, self.F = tok, d3_format
+        self.codes, _ = d3_format.answer_codes(tok)
+
+    def state_of(self, parts, target, text):
+        if len(parts) == 1:
+            return text, 0
+        blocks, t0, pos = [], None, 0
+        for ro, t in parts:
+            hdr = f"{ro}:\n"; body = text if ro == target else t
+            if ro == target:
+                t0 = pos + len(hdr)
+            blocks.append(hdr + body); pos += len(hdr) + len(body) + 2
+        return "\n\n".join(blocks), t0
+
+    def __call__(self, parts, target, question, labels, text, n_images=0, processor=None):
+        F_ = self.F
+        state, t0 = self.state_of(parts, target, text)
+        opt_lines = [f"{c}: {n if not d else n + ': ' + d}" for c, (n, d) in zip(self.codes, labels)]
+        head = ["State:", state if state else "(empty)", "", "Question:", question, "", "Options:"]
+        user = "\n".join(head + opt_lines + ["", "Reply with only the code of the best option."])
+        if n_images:  # d3's image layout: one placeholder per image before the user text, rendered by the checkpoint's processor
+            content = [{"type": "image"} for _ in range(n_images)] + [{"type": "text", "text": user}]
+            rendered = processor.apply_chat_template([{"role": "system", "content": F_.SYSTEM_PROMPT}, {"role": "user", "content": content}],
+                                                     tokenize=False, add_generation_prompt=True, enable_thinking=False)
+        else:
+            rendered = self.tok.apply_chat_template([{"role": "system", "content": F_.SYSTEM_PROMPT}, {"role": "user", "content": user}],
+                                                    tokenize=False, add_generation_prompt=True, enable_thinking=False)
+        u0 = rendered.index(user); s0 = u0 + len("State:\n") + t0
+        e = self.tok(rendered, add_special_tokens=False, return_offsets_mapping=True)
+        ids = list(e["input_ids"]); offs = np.asarray(e["offset_mapping"], dtype=np.int64).reshape(-1, 2)
+        wo, ft = word_first_tokens(text, offs - s0)
+        pos = u0 + len("\n".join(head)) + 1; ranges = []; st, en = offs[:, 0], offs[:, 1]
+        for ol in opt_lines:
+            ix = np.nonzero((st < pos + len(ol)) & (en > pos))[0]; ranges.append((int(ix[0]), int(ix[-1]))); pos += len(ol) + 1
+        rec = dict(ids=ids, w_pos=ft.astype(np.int64), w_offs=wo, ranges=ranges)
+        if n_images:
+            rec["rendered"] = rendered
+        return rec
+
+
+class SpanEngine:
+    """One span head on the final-norm states; its adapter ("span" or "ner") is on for every forward of this engine."""
+
+    def __init__(self, runtime, head, adapters, d3_format, adapter="span"):
+        self.rt, self.head, self.A, self.adapter = runtime, head, adapters, adapter
+        self.R = Render(runtime.tokenizer, d3_format)
+
+    def n_tokens(self, text):
+        return len(self.rt.tokenizer(text, add_special_tokens=False)["input_ids"])
+
+    def _pieces(self, parts, target, question, labels):
+        text = dict(parts)[target]
+        e = self.rt.tokenizer(text, add_special_tokens=False, return_offsets_mapping=True)
+        ids = e["input_ids"]; offs = np.asarray(e["offset_mapping"], dtype=np.int64).reshape(-1, 2)
+        if len(ids) <= RMAX:
+            return [(self.R(parts, target, question, labels, text), 0)], len(ids)
+        wo, ft = word_first_tokens(text, offs); out = []
+        for a0, b0 in windows(ft, len(ids)):
+            cs, ce = int(offs[a0][0]), int(offs[b0 - 1][1])
+            out.append((self.R(parts, target, question, labels, text[cs:ce]), cs))
+        return out, len(ids)
+
+    @torch.no_grad()
+    def logits(self, parts, target, question, labels, images=None):
+        """Word offsets (W, 2) into the target text, word x label logits (W, L), target tokens, windows."""
+        if images:
+            return self._image_logits(parts, target, question, labels, images)
+        acc = {}
+        pieces, n_tok = self._pieces(parts, target, question, labels)
+        for rec, cs in pieces:
+            if len(rec["w_offs"]) == 0:
+                continue
+            ids = torch.as_tensor([rec["ids"]], device=self.rt.device)
+            with self.A.active(self.adapter):
+                H = text_states(self.rt, ids)
+            w = H[0, torch.as_tensor(rec["w_pos"], device=H.device)]
+            lab = torch.stack([H[0, s:e + 1].mean(0) for s, e in rec["ranges"]])
+            lg = self.head(w, lab)[0].float().cpu().numpy()
+            for wi, (s, e) in enumerate(rec["w_offs"]):
+                v = acc.setdefault((int(s) + cs, int(e) + cs), [np.zeros(len(labels)), 0]); v[0] += lg[wi]; v[1] += 1
+        keys = sorted(acc)
+        wo = np.asarray(keys, dtype=np.int64).reshape(-1, 2)
+        lg = np.stack([acc[k][0] / acc[k][1] for k in keys]) if keys else np.zeros((0, len(labels)))
+        return wo, lg, n_tok, len(pieces)
+
+    @torch.no_grad()
+    def _image_logits(self, parts, target, question, labels, images):
+        """The span pass with images (decoded RGB images): d3's image layout, the processor expands each placeholder into the
+        image's visual tokens and every tensor it returns goes to the backbone (its own mRoPE positions); word and label positions
+        shift by the visual tokens. One sequence: targets longer than RMAX tokens are refused."""
+        proc = self.rt.processor
+        if proc is None:
+            raise ValueError(f"image inputs are not available: {self.rt.image_unavailable}")
+        text = dict(parts)[target]
+        n_tok = len(self.rt.tokenizer(text, add_special_tokens=False)["input_ids"])
+        if n_tok > RMAX:
+            raise ValueError(f"span questions with images take targets of up to {RMAX} tokens")
+        rec = self.R(parts, target, question, labels, text, n_images=len(images), processor=proc)
+        if len(rec["w_offs"]) == 0:
+            return np.zeros((0, 2), np.int64), np.zeros((0, len(labels))), n_tok, 1
+        enc = proc(text=[rec["rendered"]], images=list(images), return_tensors="pt")
+        ids, got = rec["ids"], enc["input_ids"][0].tolist()
+        img = self.rt.backbone.config.image_token_id
+        k = [i for i, t in enumerate(ids) if t == img]
+        sh = len(got) - len(ids)
+        if (len(k) != len(images) or sh < 0 or got[:k[0]] != ids[:k[0]] or got[k[-1] + 1 + sh:] != ids[k[-1] + 1:]
+                or (rec["w_pos"] <= k[-1]).any() or any(a <= k[-1] for a, _ in rec["ranges"])):
+            raise RuntimeError("the processor's ids differ from the text ids with the image placeholders expanded")
+        rt_mod = sys.modules.get(type(self.rt).__module__)
+        backends = getattr(rt_mod, "sdpa_backends", None)
+        inputs = {n: v.to(self.rt.device) for n, v in enc.items()}
+        with self.A.active(self.adapter), (backends(self.rt.device) if backends else contextlib.nullcontext()):
+            H = image_states(self.rt, inputs)
+        w = H[0, torch.as_tensor(rec["w_pos"] + sh, device=H.device)]
+        lab = torch.stack([H[0, s + sh:e + sh + 1].mean(0) for s, e in rec["ranges"]])
+        lg = self.head(w, lab)[0].float().cpu().numpy()
+        return np.asarray(rec["w_offs"], dtype=np.int64).reshape(-1, 2), lg, n_tok, 1