Migom 4B v0.1

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,176 @@
+                                 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

NOTICE

@@ -0,0 +1,8 @@
+Migom (migom-4b)
+Copyright 2026 Kirill Smolnikov / CapyAgent
+
+This model is a fine-tuned derivative of:
+- decider-4b (Mapika/decider-4b, revision eb5fbdfc), Apache License 2.0
+- Qwen3.5-4B-Base (Qwen/Qwen3.5-4B-Base), Apache License 2.0
+Modifications: LoRA fine-tuning (merged into the weights) on an open, commercially licensed
+Russian/English typed-decision mix and synthetic skill-routing data (see README).

README.md

@@ -0,0 +1,100 @@
+---
+language:
+  - ru
+  - en
+license: apache-2.0
+library_name: transformers
+pipeline_tag: text-classification
+tags:
+  - typed-decisions
+  - system-one
+  - russian
+  - routing
+  - agents
+  - decider
+base_model: Mapika/decider-4b
+datasets:
+  - smolnikov/RuDecide
+---
+
+# Мигом 4B (migom-4b)
+
+Собственная модель для быстрых решений, обученная нами на наших данных. Разработка Smolnikov / CapyAgent.
+Старшая модель семейства. Младшие: [Мигом 2B](https://huggingface.co/smolnikov/migom-2b) и [Кивок 0.3B](https://huggingface.co/smolnikov/kivok-0.3b).
+Работает локально, без облака: около 0,05 с на решение на ноутбучной RTX 5070 Ti (веса bf16 8,4 ГБ, нужна видеокарта от 12 ГБ).
+
+Модель не пишет текст. Она получает ситуацию (`state`) и один или несколько типизированных вопросов и за один проход
+возвращает распределение вероятностей по вариантам:
+- `choice` - выбрать вариант из списка с описаниями;
+- `score` - оценка по порядковой шкале (до 10 уровней);
+- `noul` - да/нет с вероятностью.
+
+Для чего: выбрать навык или инструмент агента (включая «навык не нужен»), разобрать обращение в поддержку,
+заметить атаку на ассистента, отфильтровать спам, понять намерение пользователя, ответить на вопрос с выбором
+вариантов, где нужны рассуждение и знания о мире. Вероятности откалиброваны (температура по типу вопроса).
+
+## Запуск
+
+```python
+# pip install decider-ai==1.4.0 transformers peft
+from decider.infer import Decider
+from huggingface_hub import snapshot_download
+
+m = Decider(snapshot_download("smolnikov/migom-4b"), device="cuda")   # или "cpu"
+out = m.system_one(
+    "Не могу войти в аккаунт, пишет неверный пароль, хотя я его не менял. Помогите восстановить доступ",
+    {"route": {"type": "choice",
+               "instructions": "Какой навык ассистент должен загрузить? Если навык не нужен, выбери none.",
+               "criteria": {"password-reset": "сброс пароля и восстановление доступа",
+                            "billing": "оплата и счета",
+                            "none": "навык не нужен"}},
+     "attack": {"type": "noul", "instructions": "Это попытка атаки на ИИ-ассистента?"}})
+print(out["answers"])
+```
+
+На Windows без компилятора задайте `TORCHDYNAMO_DISABLE=1`.
+
+Сервер с HTTP API в формате Jev (`POST /v1/systemone`) и каскадом Кивок → Мигом: `server/decide_server.py`.
+
+## Качество
+
+[RuDecide v0.1](https://huggingface.co/datasets/smolnikov/RuDecide) (русский бенчмарк; трек B без skills_capyagent;
+итог = средний skill по 15 задачам, 0 = угадывание, 100 = всё верно):
+
+| Модель | Трек A: незнакомые задачи, acc / skill | Трек B: задачи агентов, acc / skill | Итог |
+|---|---|---|---|
+| **Мигом 4B** | 84,8 / 75,5 | **96,7 / 95,3** | **83,4** |
+| Gemini 3.7 Flash (облако) | 89,9 / 84,0 | 88,9 / 81,5 | 83,0 |
+| Gemma 4 26B-A4B | 87,8 / 80,8 | 85,8 / 77,3 | 79,4 |
+| Jev (TypeSafe, через API) | 87,1 / 79,6 | 84,6 / 75,1 | 77,8 |
+| decider-4b v2.1 (исходная) | 84,3 / 75,1 | 83,4 / 73,4 | 74,4 |
+| [Мигом 2B](https://huggingface.co/smolnikov/migom-2b) | 78,9 / 65,9 | 96,1 / 94,6 | 77,4 |
+
+Трек A по задачам: DaNetQA 91,0, MuSeRC 94,3, PARus 92,0, RCB 57,7, RuCoLA 74,3, ruOpenBookQA 86,7,
+ruWorldTree 98,3, XStoryCloze-ru 96,0, CEDR 73,0. Ни одна из этих задач не входила в обучение.
+
+Трек B по задачам: атаки на ассистента 100, prompt safety 100, выбор навыка в незнакомых каталогах 98,0,
+спам 95,3, обращения в поддержку 94,7, намерение пользователя (MASSIVE ru) 92,0. Калибровка: ECE 0,012.
+
+Честно об ограничениях: трек B собран из тех же открытых источников, что и обучение (тестовые примеры отложены),
+поэтому там у Мигома домашнее поле. На незнакомых задачах с рассуж��ением (трек A) Мигом 4B отстаёт от Jev на 2,3 пункта
+точности. Длинные контексты (больше ~1 500 токенов) в дообучении не участвовали. Жалобу без явной просьбы
+(«не могу войти, пишет неверный пароль») модель может отнести к «навык не нужен»: опирайтесь на вероятности.
+
+## Данные и обучение
+
+Только открытые данные, лицензии которых разрешают коммерческое использование, и синтетика от открытой модели.
+Без личных данных и без ответов закрытых коммерческих моделей (ответы Jev использовались только для сравнения).
+
+22 620 примеров, 1 эпоха, LoRA rank 32 (alpha 64) на attention и MLP, LR 1e-4, fp16 на T4 (Kaggle), влита в веса bf16.
+Источники: LocalLLaMA/typed-decisions, tasksource/procedural-typed-decisions (Apache-2.0); MASSIVE ru (CC BY 4.0);
+TERRa (Russian SuperGLUE, MIT); ai-forever headline / ru-reviews / kinopoisk (MIT, Apache-2.0);
+A11Sunday/support-json-ru, nvidia/When2Call (CC BY 4.0); Mapika/decider teacher data (Apache-2.0);
+DmitryKRX/anti_spam_ru, dmtrdr/russian_prompt_injections (Apache-2.0); Nailyk14/prompt-safety-multilingual
+(только строки с Apache/MIT); синтетика выбора навыка по 40 выдуманным каталогам и короткие диалоги,
+сгенерированные DeepSeek (MIT). Скрипты: папка `training/` (`train_decider_lora.py` - само дообучение).
+
+## Лицензия
+
+Apache-2.0. Модель дообучена из [decider-4b](https://huggingface.co/Mapika/decider-4b) (Apache-2.0) на основе
+[Qwen3.5-4B-Base](https://huggingface.co/Qwen/Qwen3.5-4B-Base) (Apache-2.0), см. `NOTICE`.

chat_template.jinja

@@ -0,0 +1,154 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {{- '<|im_start|>system\n' + content + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- else %}
+            {%- if '</think>' in content %}
+                {%- set reasoning_content = content.split('</think>')[0].rstrip('\n').split('<think>')[-1].lstrip('\n') %}
+                {%- set content = content.split('</think>')[-1].lstrip('\n') %}
+            {%- endif %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | tojson | safe if args_value is mapping or (args_value is sequence and args_value is not string) else args_value | string %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

config.json

@@ -0,0 +1,83 @@
+{
+  "architectures": [
+    "Qwen3_5ForCausalLM"
+  ],
+  "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": 2560,
+  "initializer_range": 0.02,
+  "intermediate_size": 9216,
+  "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": true,
+  "transformers_version": "5.17.0",
+  "use_cache": true,
+  "vocab_size": 248320
+}

decider_config.json

@@ -0,0 +1,21 @@
+{
+ "temperature": 1.099,
+ "temperature_by_type": {
+  "choice": 1.11,
+  "noul": 1.56,
+  "score": 1.287
+ },
+ "neutralize_none": false,
+ "version": "migom-4b-0.1",
+ "base": "Mapika/decider-4b v1 + LoRA (merged); v1 is Qwen/Qwen3.5-4B-Base + one supervised pass over mixture v2",
+ "layout": "plain",
+ "max_options": 255,
+ "max_state_tokens": 32768,
+ "schema_first": false,
+ "schema_first_trained": false,
+ "isolated_levels": true,
+ "release_date": "2026-09-24",
+ "requires": "decider-ai>=1.4.0 for temperature_by_type; older versions serve every answer at temperature",
+ "stage": "LoRA r32 (alpha 64) on attention+MLP, 1 epoch over 22,620 rows of an open commercially licensed Russian/English typed-decision mix, merged into bf16 weights",
+ "parent": "4b-v2.1"
+}

generation_config.json

@@ -0,0 +1,6 @@
+{
+  "_from_model_config": true,
+  "eos_token_id": 248044,
+  "transformers_version": "5.17.0",
+  "use_cache": true
+}

model.safetensors

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

server/decide_server.py

@@ -0,0 +1,122 @@
+"""Open typed-decision server with a Jev-compatible API.
+
+POST /v1/systemone  {"state": ..., "questions": {id: {"type": "choice|score|noul", "instructions": ..., "criteria": ...}},
+                     "model": "kivok" | "migom" | "auto"}
+  -> {"model": ..., "answers": {id: {...TypeSafe answer shape...}}, "usage": {...}}
+GET  /v1/models
+
+Models:
+  kivok - small (0.3B) and fast, runs on CPU;
+  migom - larger (2B), better at reasoning; GPU recommended;
+  auto  - cascade: Kivok answers, questions where its top probability is below AUTO_THRESHOLD go to Migom.
+
+Env: KIVOK_PATH, MIGOM_PATH (either may be empty), DEVICE (cpu|cuda|xpu), DTYPE (fp16|bf16|fp32; use fp16 on Intel XPU),
+     GRAPHS (0 disables graphs), AUTO_THRESHOLD (default 0.8),
+     API_KEY (if set, require "Authorization: Bearer <key>"), HOST (default 127.0.0.1), PORT (default 8010).
+"""
+import hmac, os, threading, time
+from typing import Any, Dict, Optional
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+KIVOK_PATH = os.environ.get('KIVOK_PATH', '')
+MIGOM_PATH = os.environ.get('MIGOM_PATH', '')
+DEVICE = os.environ.get('DEVICE') or None
+THRESHOLD = float(os.environ.get('AUTO_THRESHOLD', '0.8'))
+API_KEY = os.environ.get('API_KEY', '')
+DTYPE = os.environ.get('DTYPE', '')  # fp16 on Intel XPU: bf16 gives wrong answers there
+GRAPHS = os.environ.get('GRAPHS', '')  # '0' disables CUDA/XPU graphs
+
+app = FastAPI(title='typed-decision server', version='0.1')
+_lock = threading.Lock()
+_models: Dict[str, Any] = {}
+
+
+def kivok():
+    if 'kivok' not in _models:
+        if not KIVOK_PATH:
+            raise HTTPException(503, 'kivok is not configured (KIVOK_PATH)')
+        import laya
+        _models['kivok'] = laya.load(KIVOK_PATH, device=DEVICE) if DEVICE else laya.load(KIVOK_PATH)
+    return _models['kivok']
+
+
+def migom():
+    if 'migom' not in _models:
+        if not MIGOM_PATH:
+            raise HTTPException(503, 'migom is not configured (MIGOM_PATH)')
+        from decider.infer import Decider
+        import torch
+        dt = {'fp16': torch.float16, 'bf16': torch.bfloat16, 'fp32': torch.float32}.get(DTYPE)
+        _models['migom'] = Decider(MIGOM_PATH, device=DEVICE, dtype=dt, use_graphs=False if GRAPHS == '0' else None)
+    return _models['migom']
+
+
+def top_prob(ans: dict) -> float:
+    if 'probabilities' in ans and ans['probabilities']:
+        return max(ans['probabilities'].values())
+    if 'noul' in ans:
+        p = float(ans['noul']); return max(p, 1 - p)
+    return 1.0
+
+
+def ask_kivok(state, questions):
+    return kivok().predict(state, questions)
+
+
+def ask_migom(state, questions):
+    return migom().system_one(state, questions)
+
+
+class Request_(BaseModel):
+    state: Any
+    questions: Dict[str, Dict[str, Any]]
+    model: Optional[str] = 'auto'
+
+
+@app.middleware('http')
+async def auth(request: Request, call_next):
+    if API_KEY and request.url.path.startswith('/v1') and not hmac.compare_digest(
+            request.headers.get('authorization', ''), f'Bearer {API_KEY}'):
+        return JSONResponse({'detail': 'missing or invalid API key'}, 401)
+    return await call_next(request)
+
+
+@app.get('/v1/models')
+def models():
+    return {'data': [{'id': m, 'configured': bool(p)} for m, p in
+                     (('kivok', KIVOK_PATH), ('migom', MIGOM_PATH), ('auto', KIVOK_PATH or MIGOM_PATH))]}
+
+
+@app.post('/v1/systemone')
+def systemone(req: Request_):
+    if not req.questions:
+        raise HTTPException(422, 'questions must not be empty')
+    name = (req.model or 'auto').lower()
+    t0 = time.time()
+    with _lock:
+        try:
+            if name == 'kivok' or (name == 'auto' and not MIGOM_PATH):
+                out = ask_kivok(req.state, req.questions); used = {k: 'kivok' for k in req.questions}
+            elif name == 'migom' or (name == 'auto' and not KIVOK_PATH):
+                out = ask_migom(req.state, req.questions); used = {k: 'migom' for k in req.questions}
+            elif name == 'auto':
+                out = ask_kivok(req.state, req.questions)
+                used = {k: 'kivok' for k in req.questions}
+                hard = {k: q for k, q in req.questions.items() if top_prob(out['answers'][k]) < THRESHOLD}
+                if hard:
+                    second = ask_migom(req.state, hard)
+                    for k in hard:
+                        out['answers'][k] = second['answers'][k]; used[k] = 'migom'
+            else:
+                raise HTTPException(404, f'unknown model {name!r}')
+        except ValueError as e:
+            raise HTTPException(422, str(e))
+    return {'model': name, 'answers': out['answers'], 'routed': used,
+            'usage': {'latency_ms': round(1000 * (time.time() - t0), 1)}}
+
+
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host=os.environ.get('HOST', '127.0.0.1'), port=int(os.environ.get('PORT', '8010')))

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,32 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|endoftext|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen2Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}

training/bench.py

@@ -0,0 +1,50 @@
+"""In-process zero-shot benchmark of Jev-like models on our skill-routing test set.
+python bench.py {jevk5|decider} MODEL_DIR data/test.jsonl out.json [--limit N]"""
+import json, sys, time, argparse, os, collections
+os.environ.setdefault('HF_HUB_OFFLINE', '1')
+sys.stdout.reconfigure(encoding='utf-8')
+ap = argparse.ArgumentParser(); ap.add_argument('backend'); ap.add_argument('model'); ap.add_argument('data'); ap.add_argument('out')
+ap.add_argument('--limit', type=int, default=0); ap.add_argument('--device', default='xpu'); ap.add_argument('--dtype', default=''); ap.add_argument('--no-graphs', action='store_true')
+ap.add_argument('--ins', default="Which skill should the assistant load to handle this user message? Choose none if no special skill is needed.")
+a = ap.parse_args()
+if a.backend == 'jevk5':
+    from jevk5.runtime import JevK5
+    m = JevK5(a.model, device=a.device, graphs=False)
+    def probs(state, q): return m.probabilities(state, q)[0]
+elif a.backend == 'decider':
+    from decider.infer import Decider
+    import torch
+    m = Decider(a.model, device=a.device, dtype={'fp16': torch.float16, 'bf16': torch.bfloat16}.get(a.dtype),
+                use_graphs=False if a.no_graphs else None)
+    def probs(state, q):
+        ans = m.system_one(state, {'x': q})['answers']['x']
+        if 'probabilities' in ans: return {str(k): v for k, v in ans['probabilities'].items()}
+        p = float(ans.get('noul', 0.5)); return {'true': p, 'false': 1 - p}
+rows = [json.loads(l) for l in open(a.data, encoding='utf-8')]
+rows = rows[:a.limit] if a.limit else rows
+skipped = 0
+res = []; lat = []; bins = [[0, 0, 0] for _ in range(10)]; ok = po = no = npos = nn = 0
+for i, r in enumerate(rows):
+    t = r['q'].get('t', 'choice')
+    q = {'type': t, 'instructions': a.ins if t == 'choice' and 'source' not in r else r['q']['ins'], 'criteria': r['q']['crit']}
+    t = time.time()
+    try:
+        p = probs(r['state'][:6000], q)
+    except ValueError as e:
+        skipped += 1; continue
+    lat.append(time.time() - t)
+    pred = max(p, key=p.get); c = p[pred]; g = pred == r['gold']; ok += g
+    if r['gold'] == 'none': nn += 1; no += g
+    else: npos += 1; po += g
+    b = min(9, int(c * 10)); bins[b][0] += 1; bins[b][1] += c; bins[b][2] += g
+    res.append({'gold': r['gold'], 'pred': pred, 'conf': c, 'src': r.get('source', 'unknown'), 'k': len(r.get('opts') or r['q']['crit'] or [0, 0])})
+    if (i + 1) % 50 == 0: print(i + 1, 'acc', round(ok / len(res), 3), 'lat', round(sorted(lat)[len(lat)//2], 3), flush=True)
+n = len(res)
+mt = {'model': os.path.basename(a.model.rstrip('\\/')), 'n': n, 'acc': round(ok / n, 4), 'acc_skill': round(po / max(1, npos), 4),
+      'acc_none': round(no / max(1, nn), 4), 'ece': round(sum(abs(b[1] - b[2]) for b in bins if b[0]) / n, 4),
+      'lat_median_s': round(sorted(lat)[n // 2], 3)}
+bs = collections.defaultdict(list)
+for x in res: bs[x['src']].append(x['gold'] == x['pred'])
+mt['skipped'] = skipped
+mt['by_src'] = {k: round(sum(v) / len(v), 3) for k, v in sorted(bs.items())}
+print('RESULT', json.dumps(mt)); json.dump({'metrics': mt, 'rows': res}, open(a.out, 'w'))

training/build_public.py

@@ -0,0 +1,305 @@
+"""Build the public (commercially clean) typed-decision mix for Kivok/Migom.
+
+Every source below was license-checked 25.09.2026 (Apache/MIT/CC-BY/CC0). No personal data,
+no outputs of closed commercial models. Output records:
+  {"state", "q": {"t", "ins", "crit"}, "opts": [labels in render order], "target": [...],
+   "gold": label, "source"}
+Usage (WSL venv with `datasets`): python build_public.py OUT_DIR
+"""
+import json, random, sys, os, urllib.request, collections
+from datasets import load_dataset, get_dataset_config_names
+
+OUT = sys.argv[1]
+rng = random.Random(20260925)
+MAX_OPTS = 20
+CAP_TRAIN = {'*': 3000, 'support_ru': 4000, 'typed_decisions': 4000}
+recs = collections.defaultdict(list)  # split -> records
+stats = collections.Counter()
+
+
+def add(split, source, state, t, ins, crit, target, gold=None):
+    if t == 'choice':
+        opts = list(crit)
+    elif t == 'score':
+        opts = [str(i) for i in range(len(crit))]
+    else:
+        opts = ['false', 'true']
+    if not (2 <= len(opts) <= MAX_OPTS) or len(target) != len(opts):
+        return
+    s = sum(target)
+    if s <= 0:
+        return
+    target = [v / s for v in target]
+    if gold is None:
+        gold = opts[max(range(len(target)), key=target.__getitem__)]
+    if isinstance(state, (dict, list)):
+        state = json.dumps(state, ensure_ascii=False)
+    state = str(state)[:6000]
+    if not state.strip():
+        return
+    recs[split].append({'state': state, 'q': {'t': t, 'ins': ins, 'crit': crit}, 'opts': opts,
+                        'target': target, 'gold': str(gold), 'source': source})
+    stats[(split, source)] += 1
+
+
+def onehot(opts, gold):
+    return [1.0 if o == gold else 0.0 for o in opts]
+
+
+def sample(ds, n):
+    idx = list(range(len(ds)))
+    rng.shuffle(idx)
+    return ds.select(idx[:n]) if n < len(idx) else ds
+
+
+def jload(x):
+    return json.loads(x) if isinstance(x, str) else x
+
+
+# 1. LocalLLaMA/typed-decisions (apache-2.0): native format, soft gold.
+def typed_decisions():
+    for split, out in (('train', 'train'), ('test', 'test')):
+        ds = load_dataset('LocalLLaMA/typed-decisions', 'all', split=split)
+        for r in ds:
+            qs, gold = jload(r['questions']), jload(r['gold'])
+            for qid, q in qs.items():
+                g = gold.get(qid)
+                if not g:
+                    continue
+                t, crit, p = q['type'], q.get('criteria'), g.get('probabilities', {})
+                if t == 'choice':
+                    tgt = [p.get(k, 0.0) for k in crit]
+                elif t == 'score':
+                    tgt = [p.get(str(i), 0.0) for i in range(len(crit))]
+                else:
+                    tgt = [p.get('false', 0.5), p.get('true', 0.5)]
+                    crit = crit if isinstance(crit, dict) and set(crit) == {'false', 'true'} else None
+                add(out, 'typed_decisions', r['state'], t, q['instructions'], crit, tgt)
+
+
+# 2. tasksource/procedural-typed-decisions (apache-2.0): rule-computed labels over structured state.
+def procedural(per_cfg_train=600, per_cfg_test=40):
+    for cfg in get_dataset_config_names('tasksource/procedural-typed-decisions'):
+        for split, out, n in (('train', 'train', per_cfg_train), ('test', 'test', per_cfg_test)):
+            try:
+                ds = sample(load_dataset('tasksource/procedural-typed-decisions', cfg, split=split), n)
+            except Exception as e:
+                print('skip', cfg, split, e); continue
+            for r in ds:
+                qs, ans = jload(r['questions']), jload(r['answers'])
+                qid = rng.choice(list(qs))  # one question per state keeps the mix balanced
+                q, a = qs[qid], ans.get(qid)
+                if not a:
+                    continue
+                t, crit = q['type'], q.get('criteria')
+                if t == 'noul':
+                    p = float(a.get('noul', 0.5)); tgt = [1 - p, p]; crit = None
+                elif t == 'score':
+                    pr = a.get('probabilities', {}); tgt = [pr.get(str(i), 0.0) for i in range(len(crit))]
+                else:
+                    pr = a.get('probabilities', {}); crit = crit if isinstance(crit, dict) else dict.fromkeys(crit)
+                    tgt = [pr.get(k, 0.0) for k in crit]
+                add(out, 'procedural', r['state'], t, q['instructions'], crit, tgt)
+
+
+# 3. MASSIVE ru (cc-by-4.0): scenario choice, then intent within the scenario.
+def massive():
+    for split, out, n in (('train', 'train', 5000), ('validation', 'calib', 300), ('test', 'test', 400)):
+        ds = sample(load_dataset('mteb/MassiveIntentClassification', 'ru', split=split), n)
+        full = load_dataset('mteb/MassiveIntentClassification', 'ru', split='train')
+        intents = sorted(set(full['label']))
+        scen = sorted({i.split('_')[0] for i in intents})
+        by_scen = collections.defaultdict(list)
+        for i in intents:
+            by_scen[i.split('_')[0]].append(i)
+        for k, r in enumerate(ds):
+            sc = r['label'].split('_')[0]
+            if k % 2 == 0:
+                crit = {s: None for s in scen}
+                add(out, 'massive_ru_scenario', r['text'], 'choice',
+                    'К какой области относится запрос пользователя к голосовому ассистенту?', crit, onehot(list(crit), sc))
+            else:
+                opts = by_scen[sc]
+                if len(opts) < 2:
+                    continue
+                crit = {i: i.split('_', 1)[1].replace('_', ' ') for i in opts}
+                add(out, 'massive_ru_intent', r['text'], 'choice',
+                    'Какое действие просит выполнить пользователь?', crit, onehot(opts, r['label']))
+
+
+# 4. TERRa (Russian SuperGLUE, MIT): textual entailment -> noul.
+def terra():
+    for split, out, n in (('train', 'train', 3000), ('dev', 'test', 300)):
+        ds = sample(load_dataset('mteb/TERRa', split=split), n)
+        for r in ds:
+            p = 1.0 if int(r['labels']) == 1 else 0.0
+            add(out, 'terra_ru', f"Текст: {r['sentence1']}\nУтверждение: {r['sentence2']}", 'noul',
+                'Следует ли утверждение из текста?', None, [1 - p, p])
+
+
+# 5. ai-forever classification (MIT/apache): headline topic (choice), review sentiment (score).
+def ai_forever():
+    ds = load_dataset('ai-forever/headline-classification')
+    labels = sorted(set(ds['train']['label_text']))
+    for split, out, n in (('train', 'train', 3000), ('validation', 'calib', 150), ('test', 'test', 300)):
+        for r in sample(ds[split], n):
+            add(out, 'headline_ru', r['text'], 'choice', 'Какая тема у новостного заголовка?',
+                {l: None for l in labels}, onehot(labels, r['label_text']))
+    for name, src, n_tr in (('ai-forever/ru-reviews-classification', 'reviews_ru', 3000),
+                            ('ai-forever/kinopoisk-sentiment-classification', 'kinopoisk_ru', 2000)):
+        ds = load_dataset(name)
+        names = {}
+        for r in ds['train']:
+            names[int(r['label'])] = r['label_text']
+        levels = [f'{names[i]}' for i in sorted(names)]
+        for split, out, n in (('train', 'train', n_tr), ('validation', 'calib', 100), ('test', 'test', 250)):
+            for r in sample(ds[split], n):
+                tgt = onehot(list(range(len(levels))), int(r['label']))
+                add(out, src, r['text'], 'score', 'Насколько положителен отзыв?', levels, tgt)
+
+
+# 6. A11Sunday/support-json-ru (cc-by-4.0): Russian support triage, several questions per ticket.
+SUP_CAT = {'billing': 'оплата, счета, списания', 'cancellation': 'отмена подписки или услуги',
+           'refund': 'возврат денег', 'product': 'вопросы о продукте и тарифах',
+           'integration': 'интеграции и API', 'access': 'доступ к аккаунту, вход',
+           'technical': 'технические сбои и ошибки'}
+SUP_ACT = {'answer': 'ответить самому', 'ask_details': 'уточнить недостающие данные',
+           'propose_action': 'предложить действие по правилам', 'escalate': 'передать человеку'}
+PRIO = ['low', 'medium', 'high', 'critical']
+SENT = ['negative', 'neutral', 'positive']
+
+
+def support():
+    for cfg, split, out in (('expanded_trained', 'train', 'train'), ('selected', 'validation', 'calib'), ('selected', 'test', 'test')):
+        for r in load_dataset('A11Sunday/support-json-ru', cfg, split=split):
+            pol = '\n'.join(p['text'] for p in jload(r['policies_json']))
+            facts = '; '.join(f"{f['key']}={f['value']}" for f in jload(r['facts_json']))
+            st = f"Обращение: {r['message']}\nПравила: {pol}\nФакты: {facts or 'нет'}"
+            add(out, 'support_ru', st, 'choice', 'К какой категории относится обращение?', SUP_CAT, onehot(list(SUP_CAT), r['category']))
+            add(out, 'support_ru', st, 'choice', 'Что должна сделать поддержка по правилам?', SUP_ACT, onehot(list(SUP_ACT), r['action']))
+            if r['priority'] in PRIO:
+                add(out, 'support_ru', st, 'score', 'Какой приоритет у обращения?',
+                    ['низкий', 'средний', 'высокий', 'критический'], onehot(PRIO, r['priority']))
+            if r['sentiment'] in SENT:
+                add(out, 'support_ru', st, 'score', 'Какой тон у клиента?', ['негативный', 'нейтральный', 'позитивный'], onehot(SENT, r['sentiment']))
+            e = 1.0 if r['human_escalation'] else 0.0
+            add(out, 'support_ru', st, 'noul', 'Нужно ли передать обращение человеку?', None, [1 - e, e])
+
+
+# 7. nvidia/When2Call (cc-by-4.0): should the assistant call a tool right now?
+def when2call(n_train=3000, n_test=300):
+    ds = load_dataset('nvidia/When2Call', 'train_pref', split='train')
+    idx = list(range(len(ds))); rng.shuffle(idx)
+    for k, i in enumerate(idx[:n_train + n_test]):
+        r = ds[i]
+        raw = r['tools']
+        raw = eval(raw) if isinstance(raw, str) else (raw or [])
+        tools = [json.loads(t) if isinstance(t, str) else t for t in raw]
+        msgs = eval(r['messages']) if isinstance(r['messages'], str) else r['messages']; user = [m['content'] for m in msgs if m['role'] == 'user'][-1]
+        ch = r['chosen_response']
+        chosen = (eval(ch) if isinstance(ch, str) else ch)['content']
+        tl = '\n'.join(f"- {t['name']}: {t.get('description', '')[:150]}" for t in tools[:8])
+        st = f"User request: {user}\nAvailable tools:\n{tl or '(none)'}"
+        p = 1.0 if '<TOOLCALL>' in chosen else 0.0
+        add('train' if k < n_train else 'test', 'when2call', st, 'noul',
+            'Should the assistant call one of the available tools now (instead of answering, asking or declining)?', None, [1 - p, p])
+
+
+# 8. Mapika/decider teacher data (Apache-2.0, teacher Qwen3.5-27B): shell risk + routing. Keep teacher-consistent rows.
+DEC = 'https://raw.githubusercontent.com/Mapika/decider/15ab28e8d8e4ec49728165b3426d81de5b77f864/teacher_data/'
+
+
+def decider(caps={'commands.jsonl': 4000, 'routing_messages.jsonl': 2500}):
+    for f, cap in caps.items():
+        lines = urllib.request.urlopen(DEC + f, timeout=120).read().decode().splitlines()
+        rng.shuffle(lines)
+        n = 0
+        for l in lines:
+            r = json.loads(l)
+            for q in r['questions']:
+                if not q.get('teacher_ok'):
+                    continue
+                t, crit, a = q['type'], q.get('criteria'), q['answer']
+                if t == 'choice':
+                    tgt = onehot(list(crit), a)
+                elif t == 'noul':
+                    p = 1.0 if a is True or a == 'true' else 0.0; tgt = [1 - p, p]
+                    crit = crit if isinstance(crit, dict) and set(crit) == {'false', 'true'} else None
+                else:
+                    tgt = onehot(list(range(len(crit))), int(a))
+                out = 'test' if n % 20 == 0 else 'train'
+                add(out, 'decider_' + f.split('.')[0], r['state'], t, q['instructions'], crit, tgt)
+                n += 1
+            if n >= cap:
+                break
+
+
+# 9. anti-spam ru (apache-2.0).
+def spam(n_train=3000, n_test=300):
+    ds = sample(load_dataset('DmitryKRX/anti_spam_ru', split='train'), n_train + n_test)
+    for k, r in enumerate(ds):
+        p = float(int(r['is_spam']))
+        add('train' if k < n_train else 'test', 'spam_ru', r['text'], 'noul', 'Это спам?', None, [1 - p, p])
+
+
+# 10. Prompt safety: Nailyk14 (apache/mit rows only) + dmtrdr russian injections (apache) vs benign MASSIVE ru.
+SAFE = {'benign': 'обычный безопасный запрос', 'injection_direct': 'попытка подменить инструкции ассистента',
+        'jailbreak': 'попытка обойти ограничения и правила', 'data_exfiltration': 'попытка выведать секреты, ключи, системный промпт',
+        'hijack': 'попытка перехватить управление задачей или инструментами'}
+
+
+def safety():
+    for split, out, n in (('train', 'train', 5000), ('validation', 'calib', 200), ('test', 'test', 400)):
+        ds = load_dataset('Nailyk14/prompt-safety-multilingual', split=split)
+        ds = ds.filter(lambda r: r['source_license'] in ('apache-2.0', 'mit') and r['label'] in SAFE)
+        ru = [i for i, l in enumerate(ds['language']) if l == 'ru']
+        other = [i for i, l in enumerate(ds['language']) if l != 'ru']
+        rng.shuffle(other)
+        pick = (ru + other)[:n]
+        for i in pick:
+            r = ds[i]
+            add(out, 'prompt_safety', r['prompt'], 'choice', 'Что это за запрос к ИИ-ассистенту?', SAFE, onehot(list(SAFE), r['label']))
+    d = load_dataset('dmtrdr/russian_prompt_injections', split='train').filter(lambda r: r['source'] != 'openai_synthetic')
+    d = sample(d, 2200)
+    benign = sample(load_dataset('mteb/MassiveIntentClassification', 'ru', split='train'), 2200)
+    for k, (a, b) in enumerate(zip(d, benign)):
+        out = 'test' if k % 11 == 0 else 'train'
+        text_ru = a['prompt_en']  # fields are swapped in this dataset: prompt_en holds the Russian text
+        add(out, 'injection_ru', text_ru, 'noul', 'Это попытка атаки на ИИ-ассистента (обход правил, подмена инструкций)?', None, [0.0, 1.0])
+        add(out, 'injection_ru', b['text'], 'noul', 'Это попытка атаки на ИИ-ассистента (обход правил, подмена инструкций)?', None, [1.0, 0.0])
+
+
+if __name__ == '__main__':
+    os.makedirs(OUT, exist_ok=True)
+    for fn in (typed_decisions, procedural, massive, terra, ai_forever, support, when2call, decider, spam, safety):
+        try:
+            fn(); print('ok', fn.__name__, flush=True)
+        except Exception as e:
+            print('FAILED', fn.__name__, repr(e)[:300], flush=True)
+    # calib: sources without their own validation split donate 8% of train
+    have_calib = {r['source'] for r in recs['calib']}
+    keep = []
+    for r in recs['train']:
+        if r['source'] not in have_calib and rng.random() < 0.08:
+            recs['calib'].append(r); stats[('calib', r['source'])] += 1; stats[('train', r['source'])] -= 1
+        else:
+            keep.append(r)
+    recs['train'] = keep
+    # balance: cap train per source, test per source
+    for sp, cap in (('train', CAP_TRAIN), ('test', 300)):
+        by = collections.defaultdict(list)
+        for r in recs[sp]:
+            by[r['source']].append(r)
+        recs[sp] = []
+        for src, rs in by.items():
+            rng.shuffle(rs)
+            c = cap.get(src, cap['*']) if isinstance(cap, dict) else cap
+            recs[sp] += rs[:c]
+            stats[(sp, src)] = min(len(rs), c)
+    for sp, rs in recs.items():
+        rng.shuffle(rs)
+        with open(os.path.join(OUT, f'pub_{sp}.jsonl'), 'w', encoding='utf-8') as f:
+            for r in rs:
+                f.write(json.dumps(r, ensure_ascii=False) + '\n')
+    for sp in ('train', 'calib', 'test'):
+        print(sp, len(recs[sp]), {s: c for (p, s), c in sorted(stats.items()) if p == sp})

training/build_skills_mix.py

@@ -0,0 +1,77 @@
+"""Assemble synthetic skill-routing questions (with a `none` option) and merge them into the public mix.
+
+Input: data/skills_syn/{catalogs,messages,negatives}.json (gen_skills.py) + data/pub/pub_*.jsonl.
+Output: data/pub2/pub_{train,calib,test}.jsonl. Held-out catalogs go to test/calib only, so the
+test measures routing over skills the model never saw.
+"""
+import json, random, os, collections
+rng = random.Random(20260926)
+D = os.environ.get('DATA_DIR', 'data')
+cats = json.load(open(f'{D}/skills_syn/catalogs.json', encoding='utf-8'))
+msgs = json.load(open(f'{D}/skills_syn/messages.json', encoding='utf-8'))
+negs = json.load(open(f'{D}/skills_syn/negatives.json', encoding='utf-8'))
+
+NONE_DESC_RU = 'навык не нужен: обычный разговор, вопрос или задача без специального навыка'
+NONE_DESC_EN = 'no skill needed: small talk, a general question or a task without a special skill'
+INS_RU = 'Какой навык ассистент должен загрузить, чтобы выполнить это сообщение пользователя? Если специальный навык не нужен, выбери none.'
+INS_EN = 'Which skill should the assistant load to handle this user message? Choose none if no special skill is needed.'
+NOUL_RU = 'Нужен ли ассистенту специальный навык (инструмент), чтобы выполнить это сообщение?'
+
+doms = [d for d in cats if d != 'capyagent']
+rng.shuffle(doms)
+held = set(doms[:6])            # unseen catalogs -> test
+calib_doms = set(doms[6:9])     # unseen catalogs -> calib
+def split_of(dom):
+    if dom in held:
+        return 'test'
+    if dom in calib_doms:
+        return 'calib'
+    if dom == 'capyagent':
+        r = rng.random()
+        return 'test' if r < 0.15 else 'calib' if r < 0.22 else 'train'
+    return 'train'
+
+def is_ru(t):
+    return sum('а' <= ch.lower() <= 'я' for ch in t) > len(t) * 0.2
+
+out = collections.defaultdict(list)
+def rec(split, dom, text, gold, drop_gold=False):
+    cat = cats[dom]
+    k = rng.randint(6, 16)
+    pool = [s for s in cat if s != gold]
+    opts = rng.sample(pool, min(k - 2, len(pool)))
+    if gold != 'none' and not drop_gold:
+        opts.append(gold)
+    ru = is_ru(text)
+    crit = {o: cat[o] for o in opts}
+    crit['none'] = NONE_DESC_RU if ru else NONE_DESC_EN
+    keys = list(crit); rng.shuffle(keys); crit = {k_: crit[k_] for k_ in keys}
+    g = 'none' if (gold == 'none' or drop_gold) else gold
+    src = 'skills_capy' if dom == 'capyagent' else 'skills_syn'
+    out[split].append({'state': text, 'q': {'t': 'choice', 'ins': INS_RU if ru else INS_EN, 'crit': crit},
+                       'opts': list(crit), 'target': [1.0 if o == g else 0.0 for o in crit], 'gold': g, 'source': src})
+    if rng.random() < 0.2:
+        p = 0.0 if g == 'none' else 1.0
+        out[split].append({'state': text, 'q': {'t': 'noul', 'ins': NOUL_RU, 'crit': None}, 'opts': ['false', 'true'],
+                           'target': [1 - p, p], 'gold': 'true' if p else 'false', 'source': src + '_need'})
+
+for m in msgs:
+    if m['domain'] not in cats or m['skill'] not in cats[m['domain']]:
+        continue
+    rec(split_of(m['domain']), m['domain'], m['text'], m['skill'], drop_gold=rng.random() < 0.08)
+for n in negs:
+    dom = n['domain'] if n['domain'] in cats else rng.choice(list(cats))
+    rec(split_of(dom), dom, n['text'], 'none')
+
+stats = {sp: collections.Counter(r['source'] for r in rs) for sp, rs in out.items()}
+nones = {sp: sum(r['gold'] == 'none' for r in rs if r['q']['t'] == 'choice') for sp, rs in out.items()}
+print('held-out test catalogs:', sorted(held)); print('calib catalogs:', sorted(calib_doms))
+print(stats, 'none per split:', nones)
+os.makedirs(f'{D}/pub2', exist_ok=True)
+for sp in ('train', 'calib', 'test'):
+    rows = [json.loads(l) for l in open(f'{D}/pub/pub_{sp}.jsonl', encoding='utf-8')] + out[sp]
+    rng.shuffle(rows)
+    with open(f'{D}/pub2/pub_{sp}.jsonl', 'w', encoding='utf-8') as f:
+        for r in rows:
+            f.write(json.dumps(r, ensure_ascii=False) + '\n')
+    print(sp, len(rows))

training/gen_skills.py

@@ -0,0 +1,144 @@
+"""Synthetic skill-routing data for the public Kivok/Migom (generator: DeepSeek Flash, MIT open weights).
+
+Stages (each cached to data/skills_syn/*.json, rerun resumes):
+  catalogs  - fictional assistant skill catalogs across domains (+ the real CapyAgent catalog)
+  messages  - user messages that need a given skill (ru ~75%, en ~25%)
+  negatives - messages that need no skill: small talk, general knowledge, and hard negatives
+              that mention a catalog's topics without asking for the action
+Usage: python3 gen_skills.py [catalogs|messages|negatives|all]
+"""
+import json, os, re, sys, random, threading, time, urllib.request
+from concurrent.futures import ThreadPoolExecutor
+
+OUT = os.environ.get('OUT_DIR', 'data/skills_syn')
+os.makedirs(OUT, exist_ok=True)
+MODEL = 'deepseek-flash'
+KEY = os.environ['DEEPSEEK_API_KEY']
+lock = threading.Lock()
+usage = {'in': 0, 'out': 0, 'calls': 0}
+
+DOMAINS = [
+    'интернет-магазин одежды', 'стоматологическая клиника', 'автосервис', 'агентство недвижимости', 'фитнес-клуб',
+    'бухгалтерия малого бизнеса', 'IT-отдел компании (helpdesk)', 'DevOps и сервера', 'личный ассистент для дома и семьи',
+    'умный дом', 'школа английского онлайн', 'служба доставки еды', 'турагентство', 'юридическая консультация',
+    'HR и найм', 'маркетинговое агентство', 'SMM и соцсети', 'интернет-провайдер (поддержка)', 'банк (поддержка клиентов)',
+    'страховая компания', 'логистика и склад', 'производство (заводской цех)', 'ресторан', 'салон красоты',
+    'ветеринарная клиника', 'онлайн-кинотеатр', 'игровая студия', 'новостная редакция', 'исследователь и учёный',
+    'разработчик-фрилансер', 'продажи B2B и CRM', 'личные финансы', 'путешествия и поездки', 'здоровье и питание',
+    'образование для школьников', 'музыкант и продюсер', 'видеомонтаж и YouTube', 'аналитик данных', 'кибербезопасность',
+    'государственные услуги и документы',
+]
+
+
+def chat(prompt, temperature=1.0, max_tokens=3000, retries=4):
+    body = {'model': MODEL, 'messages': [{'role': 'user', 'content': prompt}], 'temperature': temperature,
+            'max_tokens': max_tokens, 'response_format': {'type': 'json_object'}}
+    for i in range(retries):
+        try:
+            req = urllib.request.Request('https://api.deepseek.com/chat/completions', json.dumps(body).encode(),
+                                         {'Authorization': 'Bearer ' + KEY, 'Content-Type': 'application/json'})
+            d = json.load(urllib.request.urlopen(req, timeout=180))
+            with lock:
+                usage['in'] += d['usage']['prompt_tokens']; usage['out'] += d['usage']['completion_tokens']; usage['calls'] += 1
+            return json.loads(d['choices'][0]['message']['content'])
+        except Exception as e:
+            print('retry', i, repr(e)[:150], flush=True)
+            time.sleep(3 * (i + 1))
+    return None
+
+
+def cached(name, fn):
+    p = os.path.join(OUT, name)
+    if os.path.exists(p):
+        return json.load(open(p, encoding='utf-8'))
+    v = fn()
+    json.dump(v, open(p, 'w', encoding='utf-8'), ensure_ascii=False, indent=1)
+    return v
+
+
+def catalogs():
+    def one(dom):
+        r = chat(f"""Придумай каталог навыков (skills) для ИИ-ассистента в сфере: «{dom}».
+Навык - это отдельная возможность, которую ассистент подгружает, чтобы выполнить задачу (например работа с календарём, выставление счёта, поиск по базе заказов).
+Верни JSON: {{"skills": [{{"name": "kebab-case-имя-латиницей", "description": "короткое описание на русском, 5-15 слов"}}]}}
+Ровно 16 навыков, разные по смыслу, без пересечений. Некоторые описания можно делать на английском (примерно 1 из 4).""", temperature=0.9)
+        if r and isinstance(r.get('skills'), list):
+            return dom, {s['name']: s['description'] for s in r['skills'] if s.get('name') and s.get('description')}
+        return dom, None
+    res = {}
+    with ThreadPoolExecutor(8) as ex:
+        for dom, cat in ex.map(one, DOMAINS):
+            if cat:
+                res[dom] = cat
+    res['capyagent'] = json.load(open(os.environ['EXTRA_CATALOG'], encoding='utf-8')) if os.environ.get('EXTRA_CATALOG') else {}
+    return res
+
+
+def messages(cats):
+    jobs = []
+    for dom, cat in cats.items():
+        items = list(cat.items())
+        for i in range(0, len(items), 4):
+            jobs.append((dom, items[i:i + 4]))
+
+    def one(job):
+        dom, items = job
+        spec = '\n'.join(f'- {n}: {d}' for n, d in items)
+        r = chat(f"""Сфера ассистента: «{dom}». Вот навыки:
+{spec}
+Для КАЖДОГО навыка напиши 9 разных сообщений пользователя, для выполнения которых ассистенту нужен именно этот навык:
+6 на русском и 3 на английском. Делай их живыми и разнообразными: короткие и длинные, вежливые и грубые, с опечатками и без,
+иногда с лишними подробностями, иногда косвенно (не называй навык прямо), иногда с упоминанием другой темы, но главная просьба - про этот навык.
+Верни JSON: {{"items": [{{"skill": "имя навыка", "messages": ["...", "..."]}}]}}""", temperature=1.0, max_tokens=4000)
+        out = []
+        if r:
+            for it in r.get('items', []):
+                if it.get('skill') in dict(items):
+                    out += [{'domain': dom, 'skill': it['skill'], 'text': m} for m in it.get('messages', []) if isinstance(m, str) and len(m) > 3]
+        return out
+    res = []
+    with ThreadPoolExecutor(8) as ex:
+        for k, o in enumerate(ex.map(one, jobs)):
+            res += o
+            if k % 20 == 0:
+                print('messages', k, len(jobs), len(res), usage, flush=True)
+    return res
+
+
+def negatives(cats):
+    jobs = [('general', None)] * 30 + [(dom, cat) for dom, cat in cats.items()]
+
+    def one(job):
+        dom, cat = job
+        if cat is None:
+            p = """Напиши 25 разных сообщений пользователя ИИ-ассистенту, для которых НЕ нужен никакой специальный навык или инструмент:
+болтовня, приветствия, благодарности, общие вопросы из головы (факты, объяснения, советы), просьбы переформулировать или придумать текст,
+мнения, шутки, короткие реакции («ок», «понял, спасибо»). 18 на русском, 7 на английском. Разная длина и стиль.
+Верни JSON: {"messages": ["...", "..."]}"""
+        else:
+            spec = '\n'.join(f'- {n}: {d}' for n, d in list(cat.items())[:16])
+            p = f"""Ассистент в сфере «{dom}» умеет вот это (навыки):
+{spec}
+Напиши 16 сообщений пользователя, которые КАСАЮТСЯ тем этих навыков, но НЕ требуют их запускать:
+рассказ о себе, эмоция, благодарность за прошлую работу, общий вопрос «как это вообще устроено», мнение, шутка, уточнение, не требующее действия.
+12 на русском, 4 на английском. Верни JSON: {{"messages": ["...", "..."]}}"""
+        r = chat(p, temperature=1.0)
+        return [{'domain': dom if cat else None, 'text': m} for m in (r or {}).get('messages', []) if isinstance(m, str) and len(m) > 1]
+    res = []
+    with ThreadPoolExecutor(8) as ex:
+        for o in ex.map(one, jobs):
+            res += o
+    return res
+
+
+if __name__ == '__main__':
+    stage = sys.argv[1] if len(sys.argv) > 1 else 'all'
+    cats = cached('catalogs.json', catalogs)
+    print('catalogs', len(cats), sum(len(c) for c in cats.values()), usage, flush=True)
+    if stage in ('messages', 'all'):
+        msgs = cached('messages.json', lambda: messages(cats))
+        print('messages', len(msgs), usage, flush=True)
+    if stage in ('negatives', 'all'):
+        neg = cached('negatives.json', lambda: negatives(cats))
+        print('negatives', len(neg), usage, flush=True)
+    print('USAGE', usage)

training/to_jevk5_pub.py

@@ -0,0 +1,24 @@
+"""Convert the public mix to JevK5 LoRA format (subset: Migom trains ~0.5 items/s on Arc)."""
+import json, random, collections, sys, os
+src_dir, out_dir, per_src_train, per_src_dev = sys.argv[1], sys.argv[2], int(sys.argv[3]), int(sys.argv[4])
+rng = random.Random(7)
+os.makedirs(out_dir, exist_ok=True)
+def conv(r, i):
+    q = r['q']; t = q['t']
+    keys = ['false', 'true'] if t == 'noul' else r['opts']
+    it = {'id': f"{r['source']}-{i}", 'source': r['source'], 'state': r['state'],
+          'question': {'type': t, 'instructions': q['ins'], 'criteria': q['crit']}, 'expected': r['gold']}
+    if max(r['target']) < 0.999:
+        it['gold_probs'] = {k: v for k, v in zip(keys, r['target'])}
+    return it
+for name, out, cap in (('pub_train', 'train', per_src_train), ('pub_calib', 'dev', per_src_dev)):
+    by = collections.defaultdict(list)
+    for l in open(os.path.join(src_dir, name + '.jsonl'), encoding='utf-8'):
+        r = json.loads(l); by[r['source']].append(r)
+    rows = []
+    for s, rs in by.items():
+        rng.shuffle(rs); rows += rs[:cap]
+    rng.shuffle(rows)
+    with open(os.path.join(out_dir, out + '.jsonl'), 'w', encoding='utf-8') as f:
+        for i, r in enumerate(rows): f.write(json.dumps(conv(r, i), ensure_ascii=False) + '\n')
+    print(out, len(rows))

training/train_decider_lora.py

@@ -0,0 +1,114 @@
+"""LoRA fine-tune of Mapika/decider-2b on our public typed-decision mix (JevK5-format jsonl: state/question/expected).
+
+Uses decider's own prompt builder (plain state-first layout, "Answer: (" slot, option-letter logits), so the
+trained model is served unchanged by decider.infer.Decider. Score questions are trained as lists (isolated=False).
+Usage: python train_decider_lora.py BASE_DIR DATA_DIR OUT_DIR [--epochs 1 --lr 1e-4 --rank 32]
+"""
+import argparse, json, os, random, shutil, sys, time, math
+import torch
+from peft import LoraConfig, get_peft_model
+from decider.model import DecisionModel, collate
+from decider.prompt import build
+from decider.data.core import Example, Q
+from decider.train import batches_by_tokens, loss_fn
+
+ap = argparse.ArgumentParser()
+ap.add_argument('base'); ap.add_argument('data'); ap.add_argument('out')
+ap.add_argument('--epochs', type=float, default=1.0); ap.add_argument('--lr', type=float, default=1e-4)
+ap.add_argument('--rank', type=int, default=32); ap.add_argument('--max-tokens', type=int, default=8192)
+ap.add_argument('--max-ctx', type=int, default=1536); ap.add_argument('--limit', type=int, default=0)
+ap.add_argument('--dtype', default='bf16', choices=['bf16', 'fp16']); ap.add_argument('--device', default='cuda')
+ap.add_argument('--max-minutes', type=float, default=0, help='stop training after this many minutes and save')
+ap.add_argument('--adapter-out', default='', help='also save the LoRA adapter here')
+ap.add_argument('--version', default='migom-2b-decider-pub1')
+a = ap.parse_args()
+sys.stdout.reconfigure(encoding='utf-8')
+rng = random.Random(0)
+dev = a.device
+DT = torch.bfloat16 if a.dtype == 'bf16' else torch.float16
+
+
+def to_example(r):
+    q = r['question']; t = q['type']; crit = q.get('criteria'); gold = str(r['expected'])
+    if t == 'choice':
+        crit = dict.fromkeys(crit) if isinstance(crit, list) else crit
+        names = list(crit); opts = [n if crit[n] in (None, '') else f'{n}: {crit[n]}' for n in names]
+        gi = names.index(gold) if gold in names else -1
+    elif t == 'score':
+        opts = [f'{i}: {c}' for i, c in enumerate(crit)]; gi = int(gold)
+    else:
+        c = crit or {}
+        f, tr = c.get('false'), c.get('true')
+        opts = ['no' if not f else f'no: {f}', 'yes' if not tr else f'yes: {tr}']
+        gi = 1 if gold == 'true' else 0
+    if gi < 0:
+        return None
+    return Example(context=r['state'], qs=[Q(text=q['instructions'], options=opts, gold=gi)], task=r.get('source', ''))
+
+
+def load(name):
+    ex = [to_example(json.loads(l)) for l in open(os.path.join(a.data, name), encoding='utf-8')]
+    ex = [e for e in ex if e]
+    return ex[:a.limit] if a.limit else ex
+
+
+t0 = time.time()
+m = DecisionModel(a.base, dtype=DT, grad_ckpt=True)
+tok = m.tok
+names = {n.rsplit('.', 1)[-1] for n, _ in m.lm.named_modules()}
+targets = [t for t in ('q_proj', 'k_proj', 'v_proj', 'o_proj', 'in_proj_qkvz', 'in_proj_ba', 'in_proj_qkv', 'in_proj_z',
+                       'in_proj_b', 'in_proj_a', 'out_proj', 'gate_proj', 'up_proj', 'down_proj') if t in names]
+peft_model = get_peft_model(m.lm, LoraConfig(r=a.rank, lora_alpha=2 * a.rank, lora_dropout=0.05, target_modules=targets))
+peft_model.print_trainable_parameters()
+m.lm = peft_model.base_model.model  # same CausalLM with LoRA layers injected in place; DecisionModel keeps calling .model / .lm_head
+m.to(dev)
+
+train = load('train.jsonl'); dev_ex = load('dev.jsonl')
+items = [build(e, tok, rng, max_options=255, max_ctx_tokens=a.max_ctx) for e in train]
+dev_items = [build(e, tok, random.Random(1), max_options=255, max_ctx_tokens=a.max_ctx) for e in dev_ex]
+print('train', len(items), 'dev', len(dev_items), flush=True)
+
+
+@torch.no_grad()
+def evaluate():
+    m.eval(); ok = n = 0
+    for idx in batches_by_tokens(dev_items, a.max_tokens, random.Random(2)):
+        b = collate([dev_items[i] for i in idx], tok.pad_token_id)
+        bt = {k: v.to(dev) if torch.is_tensor(v) else v for k, v in b.items()}
+        lg = m(bt); g = bt['golds']; msk = g >= 0
+        ok += int((lg[msk].argmax(-1) == g[msk]).sum()); n += int(msk.sum())
+    m.train(); return ok / max(1, n)
+
+
+print('before dev acc', round(evaluate(), 4), flush=True)
+params = [p for p in m.parameters() if p.requires_grad]
+opt = torch.optim.AdamW(params, lr=a.lr, weight_decay=0.0)
+plan = []
+for ep in range(math.ceil(a.epochs)):
+    plan += batches_by_tokens(items, a.max_tokens, random.Random(10 + ep))
+total = int(len(plan) * a.epochs / math.ceil(a.epochs))
+scaler = torch.amp.GradScaler('cuda', enabled=a.dtype == 'fp16')
+sch = torch.optim.lr_scheduler.LambdaLR(opt, lambda s: min(1.0, (s + 1) / 20) * 0.5 * (1 + math.cos(math.pi * s / total)))
+m.train(); win = []
+for step, idx in enumerate(plan[:total]):
+    b = collate([items[i] for i in idx], tok.pad_token_id)
+    bt = {k: v.to(dev) if torch.is_tensor(v) else v for k, v in b.items()}
+    loss, ce = loss_fn(m(bt).float(), bt['golds'], bt['nopts'])
+    opt.zero_grad(set_to_none=True); scaler.scale(loss).backward(); scaler.unscale_(opt)
+    torch.nn.utils.clip_grad_norm_(params, 1.0); scaler.step(opt); scaler.update(); sch.step()
+    win.append(loss.item())
+    if a.max_minutes and time.time() - t0 > 60 * a.max_minutes:
+        print(f'time limit: stopping at step {step + 1}/{total}', flush=True); break
+    if (step + 1) % 25 == 0:
+        eta = (total - step - 1) * (time.time() - t0) / (step + 1) / 60
+        print(f'step {step + 1}/{total} loss {sum(win) / len(win):.4f} ~{eta:.0f} min left', flush=True); win = []
+print('after dev acc', round(evaluate(), 4), flush=True)
+if a.adapter_out:
+    peft_model.save_pretrained(a.adapter_out)
+merged = peft_model.merge_and_unload()
+os.makedirs(a.out, exist_ok=True)
+merged.save_pretrained(a.out); tok.save_pretrained(a.out)
+cfg = json.load(open(os.path.join(a.base, 'decider_config.json')))
+cfg.update(version=a.version, parent=cfg.get('version'), stage=f'LoRA r{a.rank} on the open typed-decision mix, {a.epochs} epoch(s)')
+json.dump(cfg, open(os.path.join(a.out, 'decider_config.json'), 'w'), indent=1)
+print('done in', int(time.time() - t0), 's', flush=True)