Топ скоростей снова обновляется: рекорд скорости острова тоже пишется в базу

Регрессия выборочной записи (7732577): полная строка писалась только при
улучшении КПД лучшего генома острова, а рекордсмены СКОРОСТИ — почти
всегда прожорливые геномы с низким КПД (57.8 м/с при 0.5%), которые
КПД-рекорд не улучшают. Топ «по скорости» на дашборде застыл на сутки,
хотя эволюция продолжала находить всё более быстрые конфигурации
(пользователь поймал: «даже случайно никто не стал быстрее лететь»).
Теперь на каждом острове отслеживаются ДВА записываемых рекорда — КПД и
скорость; это по-прежнему максимум пара строк на остров за поколение.

PLAN.md

@@ -55,7 +55,7 @@ L(x, I)-модель с coenergy-выводом силы — в разделе "
   - **Найден и исправлен реальный баг именно на этом этапе**: КПД лучшего генома после `evolve` показал 387% — оказалось, `efficiency` считался как `exit_kinetic_energy / energy_in`, а `exit_kinetic_energy` включает фиксированный "бесплатный" толчок `initial_v_mps`, не учтённый в `energy_in`. Для лёгкого снаряда этот толчок доминировал и КПД пробивал 100%. Исправлено на `kinetic_energy_delta / energy_in` (энергия, реально добавленная катушками) — эта величина математически не может превысить 1 (следует из поэтапного энергобаланса). После исправления лучший результат на тот момент: **1 ступень, КПД 80.97%, скорость 26.4 м/с, снаряд Ст3 ⌀4мм x 30мм, стоимость 1029₽** (провод cu-petv2-1.0mm, конденсатор 22мкФ/400В, ключ IRG4PC50F, оптический датчик). *(Историческая запись: это физика v1 БЕЗ потерь в железе, скина и трения — после их добавления такие КПД невозможны, см. «хронологию честности» ниже.)*
   - **Честное сравнение датчиков** (запрос из первого обсуждения плана) — на 5000 прогонах: индукционный датчик (`inductive-pickup-lm393`) дал **0.2% реализуемых** конфигураций (6 из 2965, где он стоял хотя бы на одной ступени), тогда как оптический (TCST2103) и Холла (A3144E) — **~45-47%** реализуемых каждый. Это количественно подтверждает опасение, высказанное в самом начале обсуждения плана: индукционная катушка-датчик ненадёжна именно потому, что требует скорости выше её порога (здесь — фиксированный старт 3 м/с как раз ниже порога срабатывания реального компонента), тогда как оптика/Холл не зависят от скорости.
   - Итог: сквозная цепочка (реальные компоненты → физика → поиск → SQLite → отчёт с графиками/BOM/анимацией) работает и произвела не выдуманный, а посчитанный и перепроверенный результат.
-- [x] **Обогащённая БД + лог процесса + веб-морда** (по запросу пользователя при деплое): каждая запись `runs.decoded_summary_json` теперь содержит расстояния между катушками (`inter_stage_gaps_m`), абсолютные позиции катушек вдоль трубы, все номиналы деталей, геометрию намотки, вычисленную физику (индуктивность/сопротивление/пиковый ток/поле) и результат каждой ступени (вход/выход скорость, тайминги датчика, энергобаланс) — см. `optim/objective.py::build_detail`. Ход эксперимента пишется в `<db>.log` (`optim/progress_log.py`): прогресс, доля реализуемых, скорость, ETA, отметки нового лучшего КПД. Веб-дашборд `gausse serve` (`src/gausse/web/`, только stdlib `http.server`, self-contained HTML) — счётчики, гистограмма КПД, топ конфигураций с drill-down, причины отказа, хвост лога, автообновление 3с. В `docker-compose.yml` сервис `web` на порту 8000. 77 тестов, проверено в Docker.
+- [x] **Обогащённая БД + лог процесса + веб-морда** (по запросу пользователя при деплое): каждая запись `runs.decoded_summary_json` теперь содержит расстояния между катушками (`inter_stage_gaps_m`), абсолютные позиции катушек вдоль трубы, все номиналы деталей, геометрию намотки, вычисленную физику (индуктивность/сопротивление/пиковый ток/поле) и результат каждой ступени (вход/выход скорость, тайминги датчика, энергобаланс) — см. `optim/objective.py::build_detail`. *(УСТАРЕЛО с 2026-07-11, коммит 5c11999: полный build_detail больше НЕ хранится на каждый прогон — база раздувалась до 70ГБ; в decoded_summary_json теперь дешёвая сводка decoded_summary(), а полная детализация пересимулируется на лету из genome_json при просмотре прогона — web/rebuild.py + web/stats.run_detail.)* Ход эксперимента пишется в `<db>.log` (`optim/progress_log.py`): прогресс, доля реализуемых, скорость, ETA, отметки нового лучшего КПД. Веб-дашборд `gausse serve` (`src/gausse/web/`, только stdlib `http.server`, self-contained HTML) — счётчики, гистограмма КПД, топ конфигураций с drill-down, причины отказа, хвост лога, автообновление 3с. В `docker-compose.yml` сервис `web` на порту 8000. 77 тестов, проверено в Docker.
 
 ## Батареи конденсаторов + графики в веб-морде (по запросу пользователя)
 
@@ -102,7 +102,13 @@ L(x, I)-модель с coenergy-выводом силы — в разделе "
   CPU-эталоном — расхождение exit_v **0.084%** (tests/test_batch_sweep.py,
   test_batch_integrator.py). Стиффные конфиги, переполняющие фикс-шаг,
   честно бракуются (blew_up), а не записываются мусором.
-  - [ ] (опция) дослить cut-логику в ядро (>3.8x); GPU-батч внутрь эволюции.
+  - [x] cut-логика дослита: весь шаг = 2 fused-ядра (одно не влезает в лимит
+    параметров CUDA 4096Б). Оценка 1000 геномов: 98.5с → 6.6с (15x), ~150
+    геномов/с на 1070, сверка с numpy-эталоном 0.001%.
+  - [x] GPU-батч в эволюции: `run_evolution(use_gpu=True)` оценивает всё
+    поколение одним батчем (`evaluate_genomes_gpu`), та же формула фитнеса;
+    полировка (Nelder-Mead) остаётся точной на CPU. Сервис `gausse-evolve`
+    переведён на venv+GPU: 120 поколений × 1000 особей, ~115/с стабильно.
 
 ## Физика: найденные завышения КПД и их исправления (хронология честности)
 
@@ -134,6 +140,22 @@ L(x, I)-модель с coenergy-выводом силы — в разделе "
    слегка отрицательным (трение съело больше слабой катушки) — это честно.
    Для сравнения на одной и той же эволюции: v1 давал «38%» там, где v2 даёт
    ~8% — столько стоили неучтённые скин и трение.
+6. **gausse-physics-v3**: эволюция нашла «КПД 82%» → вскрытие генома: тонкий
+   снаряд (⌀4мм) в толстой катушке (⌀29мм) — модель умножала ВСЮ L на
+   (μ_eff−1), как будто железо заполняет всё сечение. Фикс: коэффициент
+   заполнения A_снаряда/A_катушки (iron_fill_factor). Плюс лечение зависаний
+   решателя: tanh-сглаживание сухого трения (разрывный sign(v) дробил шаг
+   бесконечно), событие тока удержания ключа (передемпфированный хвост),
+   полная формула отражения вихрей (ωM)²R₂/(R₂²+(ωL₂)²), гард вырожденных
+   катушек (L/R<100нс). Бенч: 200 геномов 608с → 22с.
+7. **gausse-physics-v4**: эволюция нашла «30%» через МЕДЛЕННУЮ катушку
+   (600+ витков, ~1мс, 36А — там слабы и Доуэлл, и вихревые, и трение).
+   Неучтённая физика: за импульс поле проникает в сталь на глубину скин-слоя
+   (~доли мм) — внутренность снаряда не намагничивается. Фикс:
+   iron_penetration_fraction = 1−(1−δ/a)² множит fill factor. После v4
+   лучший КПД эволюции — единицы процентов, что соответствует реальным
+   reluctance-пушкам. Урок зафиксирован: подозрительно красивый КПД =
+   вскрывать лучший геном и искать обойдённый канал потерь.
 
 ## Требования пользователя, закрытые после Этапа 8
 
@@ -146,11 +168,13 @@ L(x, I)-модель с coenergy-выводом силы — в разделе "
   катушку — repair()).
 - **Ссылки на магазины** (`url`) у каждого компонента: в JSON-базе, BOM
   («Купить») и в детализации прогона.
-- **Максимально детальная запись** в БД (`build_detail`): труба
+- **Максимально детальная запись** (`build_detail`): труба
   внутр/стенка/внеш, масса снаряда в граммах и влезает-ли-в-бор,
   внутр/внеш диаметры катушки, состав банки конденсаторов, DC/AC
   сопротивление обмотки, все позиции датчиков и катушек вдоль трубы,
-  энергобаланс каждой ступени.
+  энергобаланс каждой ступени. *(С 2026-07-11 НЕ хранится в БД построчно,
+  а строится на лету из genome_json при просмотре прогона/отчёте —
+  хранение полной детализации на 12.9М строк раздуло базу до 70ГБ.)*
 - **Анимация переделана** (была «время вырезается, результата не видно»):
   кадры на равномерной сетке ФИЗИЧЕСКОГО времени (а не по индексам массива,
   из-за чего плотные точки разряда съедали все кадры и подлёт выпадал),

README.md

@@ -16,6 +16,8 @@
 - **Физика** (`src/gausse/physics/`): RLC-разряд конденсаторной банки через
   катушку с ферромагнитным снарядом; насыщение железа через единое
   потокосцепление λ(x,I) (энергия сохраняется); вихревые потери в снаряде;
+  коэффициент заполнения (тонкий снаряд не усиливает весь поток) и
+  диффузия поля (за импульс намагничивается только скин-кольцо);
   скин-эффект + эффект близости обмотки (метод Доуэлла); трение о трубку и
   сопротивление воздуха; одиночный импульс (тиристор не перезапускается);
   паспортные импульсные токи ключей (ITSM/IDM/ICM из даташитов).
@@ -27,7 +29,8 @@
   полировкой; всё в одну SQLite-базу (WAL, писатель поверх очереди).
 - **GPU** (`src/gausse/gpu/`): батч-интегратор RK4 (numpy/cupy), весь шаг
   слит в одно cupy.fuse-ядро — на GTX 1070 ~3.8x к CPU; многоступенчатый
-  GPU-sweep раунд-за-раундом; сверен с CPU-эталоном (<0.1%).
+  GPU-sweep раунд-за-раундом И GPU-эволюция (use_gpu=True: всё поколение —
+  один батч, ~150 геномов/с на 1070); сверено с CPU-эталоном (<0.1%).
 - **Отчёты** (`src/gausse/report/`, `src/gausse/web/`): веб-дашборд с
   drill-down до каждой детали и энергобаланса ступени, графики ток/поле/
   скорость, GIF-анимация выстрела (равномерное физическое время, результат
@@ -65,9 +68,9 @@ pytest
 
 ## Автономная работа на сервере
 
-Эволюция оформлена как systemd-сервис `gausse-evolve` (вечный цикл: 80
+Эволюция оформлена как systemd-сервис `gausse-evolve` (вечный цикл: 120
-поколений × 300 особей, по окончании — новый цикл со свежей случайной
+поколений × 1000 особей на GPU, по окончании — новый цикл со свежей
-популяцией; `Restart=always`, автозапуск при загрузке). Дашборд — Docker-
+случайной популяцией; `Restart=always`, автозапуск при загрузке). Дашборд — Docker-
 сервис `web` на :8000, читает ту же базу. Счётчик «запланировано» на
 дашборде — план **текущего цикла**, а не всего поиска: поиск бесконечен.
 
@@ -75,13 +78,12 @@ pytest
 
 - Индуктивность — инженерная модель (Уилер + размагничивание сфероида +
   tanh-перекрытие), не МКЭ; точная картина поля требует FEA.
-- Вихревые потери снаряда — сосредоточенный виток на характерной частоте
+- Вихревые потери снаряда — сосредоточенный виток; диффузия поля в снаряд —
-  импульса; диффузия поля (скин-эффект в самом снаряде) не решается.
+  одночастотная оценка скин-кольца, а не решение уравнения диффузии.
 - Доуэлл берёт одну характерную частоту ω=1/√(LC), без спектра импульса.
 - Воздух — лобовое сопротивление; поршневой эффект столба воздуха в трубе
   не учтён. Трение — константа 0.35 (сталь-пластик), не измерено.
 - Гистерезис снаряда посчитан и сознательно не включён в динамику (<0.1%).
 - Нагрев провода за импульс и от серии выстрелов не моделируется.
 
-Версия физики пишется в каждую запись (`model_version`, сейчас
+Версия физики пишется в каждую запись (`model_version`, сейчас `gausse-physics-v4`) — прогоны разных моделей не смешиваются.
-`gausse-physics-v2`) — прогоны разных моделей не смешиваются.

deploy/README.md

@@ -0,0 +1,13 @@
+# Развёртывание на сервере (VM 106, 192.168.20.47)
+
+Автономная работа — три systemd-сервиса (все enabled, переживают ребут):
+
+| Сервис | Что делает |
+|---|---|
+| `gausse-evolve` | вечный цикл эволюции на GPU (`evolve_forever.sh`), `Restart=always`, `TimeoutStopSec=180` (дать дописать очередь в базу при остановке) |
+| `gausse-gpustat` | пишет `results/gpustat.json` каждые 5с — карточка GPU на дашборде |
+| Docker `web` | дашборд :8000 (наружу: https://gausse.jze9.ru через nginx LXC 102 + certbot) |
+
+Обновление кода: `git pull && pip install -e . (в .venv) && docker compose build web && docker compose up -d web && sudo systemctl restart gausse-evolve`.
+Остановка сервиса безопасна: главный процесс по SIGTERM дописывает всю очередь
+оценённых прогонов в базу перед выходом («сохраняем всё»).

deploy/evolve_forever.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Вечная эволюция на GPU: бесконечный конвейер циклов. Каждый цикл — свежая
+# случайная популяция («революция» против застревания в локальном оптимуме),
+# всё пишется в одну базу, дашборд показывает лучший за всё время.
+# Развёртывание: см. deploy/README.md; systemd-юнит: gausse-evolve.service.
+cd /home/user/gausse
+source .venv/bin/activate
+LOG=results/gausse.sqlite3.log
+cycle=1
+while true; do
+  best=$(python3 - <<'PY'
+import sqlite3
+try:
+    c = sqlite3.connect("results/gausse.sqlite3")
+    # НЕ max(): он сканирует всю базу (гигабайты); частичный индекс отдаёт мгновенно
+    row = c.execute("select efficiency from runs indexed by idx_runs_feas_eff "
+                    "where feasible=1 order by efficiency desc limit 1").fetchone()
+    print(f"{row[0]*100:.2f}%" if row and row[0] is not None else "пока нет")
+except Exception:
+    print("пока нет")
+PY
+)
+  echo "$(date -Is) ═════ ЦИКЛ #$cycle стартует (конвейер бесконечный; лучший КПД за всё время: $best) ═════" >> "$LOG"
+  # выборка 10000 на поколение (8 островов x 1250) — по просьбе пользователя:
+  # меньше популяция + больше поколений за цикл = быстрее углубляется.
+  # Рядовые оценки в базу не пишутся (только счётчики) — писатель больше
+  # не душит конвейер, GPU занят почти всё время цикла.
+  python3 -c "from pathlib import Path
+from gausse.optim.evolutionary import run_evolution
+try:
+    run_evolution(Path('results/gausse.sqlite3'), n_generations=120, population_size=1250, seed=None, polish=True, use_gpu=True, islands=8)
+except KeyboardInterrupt:
+    pass  # штатная остановка сервиса: база уже дописана в finally"
+  echo "$(date -Is) ═════ ЦИКЛ #$cycle завершён — это НЕ остановка: через 3с стартует цикл #$((cycle+1)) со свежей случайной популяцией ═════" >> "$LOG"
+  cycle=$((cycle+1))
+  sleep 3
+done

deploy/gausse-evolve.service

@@ -0,0 +1,15 @@
+[Unit]
+Description=gausse continuous evolution (autonomous, runs for years)
+After=network-online.target docker.service
+
+[Service]
+Type=simple
+User=user
+WorkingDirectory=/home/user/gausse
+ExecStart=/bin/bash /home/user/gausse/evolve_forever.sh
+Restart=always
+RestartSec=15
+TimeoutStopSec=180
+
+[Install]
+WantedBy=multi-user.target

deploy/gausse-gpustat.service

@@ -0,0 +1,13 @@
+[Unit]
+Description=gausse GPU stat writer for dashboard
+After=gausse-evolve.service
+
+[Service]
+Type=simple
+User=user
+ExecStart=/bin/bash /home/user/gausse/gpustat_loop.sh
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target

deploy/gpustat_loop.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Пишет загрузку GPU в results/gpustat.json для веб-морды (раз в 5с)
+cd /home/user/gausse
+while true; do
+  line=$(nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total,power.draw,temperature.gpu --format=csv,noheader,nounits 2>/dev/null)
+  if [ -n "$line" ]; then
+    IFS=", " read -r util mem memtot pw temp <<< "$line"
+    printf '{"ts": %s, "util_pct": %s, "mem_used_mib": %s, "mem_total_mib": %s, "power_w": %s, "temp_c": %s}\n' \
+      "$(date +%s)" "$util" "$mem" "$memtot" "$pw" "$temp" > results/gpustat.json.tmp
+    mv results/gpustat.json.tmp results/gpustat.json
+  fi
+  sleep 5
+done

src/gausse/gpu/batch_integrator.py

@@ -108,7 +108,8 @@ def _derivatives(xp, q, i, x, v, p: BatchDischargeParams):
     v_c = q / p.capacitance_f
     d_q = -i
     d_i = (v_c - i * r_eff - dlambda_dx * v) / dlambda_di
-    retard = xp.sign(v) * (p.retard_const_n + p.drag_coeff_n * v * v)  # трение + воздух
+    # трение + воздух; tanh-сглаживание у v=0 — как в physics/circuit.py
+    retard = xp.tanh(v / 0.01) * (p.retard_const_n + p.drag_coeff_n * v * v)
     d_v = (force - retard) / p.mass_kg
     d_x = v
     return d_q, d_i, d_x, d_v
@@ -145,7 +146,7 @@ def _get_fused_step(cp):
         reff = rt + red * ov
         dq = -i
         di = (q / C - i * reff - liron * dov * g * v) / dl_di
-        dv = (liron * dov * G - cp.sign(v) * (fc + dc * v * v)) / m
+        dv = (liron * dov * G - cp.tanh(v * 100.0) * (fc + dc * v * v)) / m
         return dq, di, v, dv
 
     @cp.fuse()
@@ -166,6 +167,97 @@ def _get_fused_step(cp):
     return step
 
 
+def _get_fused_pair(cp):
+    """Два слитых ядра на шаг: RK4+физика и cut-логика.
+
+    Профиль на 1070: RK4 был слит, но бухгалтерия обрыва (_magnetic_energy,
+    _overlap, ~15 where на шаг) запускала десятки мелких ядер и съедала >90%
+    времени. Одним ядром не влезает в лимит параметров CUDA (4096 байт,
+    «Formal parameter space overflowed»), поэтому два сбалансированных:
+    step_phys — RK4 + потери шага + остаточная магнитная энергия;
+    step_cut — обрывы/пики/выходные состояния, вообще без физических параметров.
+    """
+    if "pair" in _FUSED_STEP_CACHE:
+        return _FUSED_STEP_CACHE["pair"]
+    LN2 = 0.6931471805599453
+
+    def _der(q, i, x, v, hs, w, isat, lair, liron, C, rt, red, fc, dc, m):
+        s1 = 0.5 * (1.0 + cp.tanh((x + hs) / w * 0.5))
+        s2 = 0.5 * (1.0 + cp.tanh((hs - x) / w * 0.5))
+        ov = s1 * s2
+        dov = (s1 * s2 / w) * (s2 - s1)
+        z = i / isat
+        tz = cp.tanh(z)
+        g = isat * tz
+        gp = 1.0 - tz * tz
+        az = cp.abs(z)
+        G = isat * isat * (az + cp.log1p(cp.exp(-2.0 * az)) - LN2)
+        dl_di = lair + liron * ov * gp
+        reff = rt + red * ov
+        dq = -i
+        di = (q / C - i * reff - liron * dov * g * v) / dl_di
+        dv = (liron * dov * G - cp.tanh(v * 100.0) * (fc + dc * v * v)) / m
+        return dq, di, v, dv
+
+    @cp.fuse()
+    def step_phys(q, i, x, v, dt, hs, w, isat, lair, liron, C, rt, red, fc, dc, m):
+        a = _der(q, i, x, v, hs, w, isat, lair, liron, C, rt, red, fc, dc, m)
+        b = _der(q + dt * 0.5 * a[0], i + dt * 0.5 * a[1], x + dt * 0.5 * a[2], v + dt * 0.5 * a[3], hs, w, isat, lair, liron, C, rt, red, fc, dc, m)
+        c = _der(q + dt * 0.5 * b[0], i + dt * 0.5 * b[1], x + dt * 0.5 * b[2], v + dt * 0.5 * b[3], hs, w, isat, lair, liron, C, rt, red, fc, dc, m)
+        d = _der(q + dt * c[0], i + dt * c[1], x + dt * c[2], v + dt * c[3], hs, w, isat, lair, liron, C, rt, red, fc, dc, m)
+        qn = q + dt / 6.0 * (a[0] + 2 * b[0] + 2 * c[0] + d[0])
+        in_ = i + dt / 6.0 * (a[1] + 2 * b[1] + 2 * c[1] + d[1])
+        xn = x + dt / 6.0 * (a[2] + 2 * b[2] + 2 * c[2] + d[2])
+        vn = v + dt / 6.0 * (a[3] + 2 * b[3] + 2 * c[3] + d[3])
+        s1o = 0.5 * (1.0 + cp.tanh((x + hs) / w * 0.5))
+        s2o = 0.5 * (1.0 + cp.tanh((hs - x) / w * 0.5))
+        ov_old = s1o * s2o
+        s1n = 0.5 * (1.0 + cp.tanh((xn + hs) / w * 0.5))
+        s2n = 0.5 * (1.0 + cp.tanh((hs - xn) / w * 0.5))
+        ov_new = s1n * s2n
+        # потери шага: I²R_eff (вихревые × overlap) + трение/воздух (трапеция)
+        step_diss = 0.5 * (i * i * (rt + red * ov_old) + in_ * in_ * (rt + red * ov_new)) * dt
+        fric = 0.5 * ((fc + dc * v * v) * cp.abs(v) + (fc + dc * vn * vn) * cp.abs(vn)) * dt
+        # остаточная магнитная энергия (с насыщением) в состоянии ДО шага
+        z = i / isat
+        g = isat * cp.tanh(z)
+        az = cp.abs(z)
+        G = isat * isat * (az + cp.log1p(cp.exp(-2.0 * az)) - LN2)
+        w_mag = 0.5 * lair * i * i + liron * ov_old * (i * g - G)
+        return qn, in_, xn, vn, step_diss + fric, w_mag
+
+    @cp.fuse()
+    def step_cut(q, i, x, v, qn, in_, xn, vn, sdiss, w_mag,
+                 done, committed, past_peak, exit_v, exit_x, exit_q, peak_i, e_diss):
+        active = ~done
+        zero = 0.0 * q
+        e2 = e_diss + cp.where(active, sdiss, zero)
+        peak2 = cp.maximum(peak_i, cp.where(active, cp.abs(in_), zero))
+        past2 = past_peak | (active & (i > 1.0) & (in_ < i))
+        crossed = active & (i > 0) & (in_ <= 0)
+        decayed = active & past2 & (in_ < 0.1) & ~crossed  # ток < удержания ключа
+        local_min = active & past2 & (in_ > i) & ~crossed & ~decayed
+        cut_state = local_min | decayed  # обрыв в состоянии ДО шага
+        cut = crossed | cut_state
+        frac = cp.where(crossed, i / (i - in_ + 1e-30), zero)
+        exit_v2 = cp.where(crossed, v + frac * (vn - v), cp.where(cut_state, v, exit_v))
+        exit_x2 = cp.where(crossed, x + frac * (xn - x), cp.where(cut_state, x, exit_x))
+        exit_q2 = cp.where(crossed, q + frac * (qn - q), cp.where(cut_state, q, exit_q))
+        e3 = e2 + cp.where(cut_state, w_mag, zero)  # freewheel-диод
+        committed2 = committed | cut
+        blew = active & ~cut & ~(cp.abs(in_) < 1e30)  # inf/nan: стиффный взрыв
+        done2 = done | cut | blew
+        adv = active & ~blew
+        q2 = cp.where(adv, qn, q)
+        i2 = cp.where(adv, in_, i)
+        x2 = cp.where(adv, xn, x)
+        v2 = cp.where(adv, vn, v)
+        return q2, i2, x2, v2, done2, committed2, past2, exit_v2, exit_x2, exit_q2, peak2, e3
+
+    _FUSED_STEP_CACHE["pair"] = (step_phys, step_cut)
+    return _FUSED_STEP_CACHE["pair"]
+
+
 def integrate_batch_discharge(
     xp,
     q0,
@@ -196,9 +288,14 @@ def integrate_batch_discharge(
     energy_diss = xp.zeros(n, dtype=xp.float64)
 
     _old_err = xp.seterr(all="ignore") if hasattr(xp, "seterr") else None  # стиффные конфиги переполняют fixed-step
-    # на cupy — слитое в одно ядро RK4-ядро (cupy.fuse), на numpy — обычный путь
+    # на cupy — ВЕСЬ шаг (RK4 + cut-логика) одним fused-ядром; numpy — обычный путь
     is_cupy = xp.__name__ == "cupy"
+    fused_pair = None
     if is_cupy:
+        try:
+            fused_pair = _get_fused_pair(xp)
+        except Exception:
+            fused_pair = None  # честный fallback на пошаговый путь
         fused = _get_fused_step(xp)
         hs = (params.coil_length_m + params.slug_length_m) / 2
     # проверку «все ли готовы» делаем НЕ каждый шаг: на GPU это device->host
@@ -211,6 +308,27 @@ def integrate_batch_discharge(
 
         q_old, i_old, x_old, v_old = q, i, x, v
 
+        if fused_pair is not None:
+            # весь шаг = 2 ядра: RK4+физика, затем cut-логика (вместо ~20 мелких)
+            try:
+                qn, in_, xn, vn, sdiss, w_mag = fused_pair[0](
+                    q_old, i_old, x_old, v_old, dt, hs, params.smoothing_width_m,
+                    params.i_sat_a, params.l_air_h, params.l_iron_coeff, params.capacitance_f,
+                    params.r_total_ohm, params.r_eddy_coeff_ohm,
+                    params.retard_const_n, params.drag_coeff_n, params.mass_kg,
+                )
+                (q, i, x, v, done, committed, past_peak,
+                 exit_v, exit_x, exit_q, peak_current, energy_diss) = fused_pair[1](
+                    q_old, i_old, x_old, v_old, qn, in_, xn, vn, sdiss, w_mag,
+                    done, committed, past_peak, exit_v, exit_x, exit_q, peak_current, energy_diss,
+                )
+                continue
+            except Exception:
+                if step == 0:  # fuse не собрался — честный откат на пошаговый путь
+                    fused_pair = None
+                else:
+                    raise
+
         if is_cupy:
             q_new, i_new, x_new, v_new, overlap_old, overlap_new = fused(
                 q_old, i_old, x_old, v_old, dt, hs, params.smoothing_width_m,
@@ -242,22 +360,25 @@ def integrate_batch_discharge(
         peak_current = xp.maximum(peak_current, xp.where(active, xp.abs(i_new), 0.0))
         past_peak = past_peak | (active & (i_old > 1.0) & (i_new < i_old))
 
-        # ОДИН импульс: обрыв на нуле тока ИЛИ на первом локальном минимуме
+        # ОДИН импульс: обрыв на нуле тока, ИЛИ на первом локальном минимуме
-        # (снаряд начал подкачивать ток обратно). Что раньше.
+        # (снаряд начал подкачивать ток обратно), ИЛИ при падении ниже тока
+        # удержания ключа (передемпфированный хвост; см. physics/circuit.py).
         crossed = active & (i_old > 0) & (i_new <= 0)
-        local_min = active & past_peak & (i_new > i_old) & ~crossed
+        decayed = active & past_peak & (i_new < 0.1) & ~crossed  # I_hold=0.1А
-        cut = crossed | local_min
+        local_min = active & past_peak & (i_new > i_old) & ~crossed & ~decayed
+        cut = crossed | local_min | decayed
         # zero-crossing: интерполяция к I=0; local_min: берём состояние минимума (old)
         frac = xp.where(crossed, i_old / (i_old - i_new + 1e-30), 0.0)
         exit_v = xp.where(crossed, _interp(v_old, v_new, frac), exit_v)
         exit_x = xp.where(crossed, _interp(x_old, x_new, frac), exit_x)
         exit_q = xp.where(crossed, _interp(q_old, q_new, frac), exit_q)
-        exit_v = xp.where(local_min, v_old, exit_v)
+        cut_at_state = local_min | decayed  # обрыв в текущем состоянии (не интерп.)
-        exit_x = xp.where(local_min, x_old, exit_x)
+        exit_v = xp.where(cut_at_state, v_old, exit_v)
-        exit_q = xp.where(local_min, q_old, exit_q)
+        exit_x = xp.where(cut_at_state, x_old, exit_x)
-        # остаточная энергия катушки при обрыве на минимуме -> в потери (freewheel)
+        exit_q = xp.where(cut_at_state, q_old, exit_q)
+        # остаточная энергия катушки при обрыве -> в потери (freewheel)
         residual = _magnetic_energy(xp, x_old, i_old, params)
-        energy_diss = energy_diss + xp.where(local_min, residual, 0.0)
+        energy_diss = energy_diss + xp.where(cut_at_state, residual, 0.0)
         committed = committed | cut  # валидная коммутация
 
         # стиффный конфиг «взорвал» fixed-step (inf/nan) -> стоп, НЕ реализуем

src/gausse/gpu/batch_sweep.py

@@ -23,32 +23,118 @@ from pathlib import Path
 
 from gausse.components.database import ComponentDatabase
 from gausse.gpu.backend import get_backend, to_cpu
-from gausse.gpu.batch_integrator import integrate_batch_discharge, params_from_models
+from gausse.gpu.batch_integrator import NO_SATURATION_I_SAT, BatchDischargeParams, integrate_batch_discharge
-from gausse.optim.objective import MODEL_VERSION, build_detail
+from gausse.optim.objective import MODEL_VERSION
 from gausse.optim.progress_log import ProgressLogger, default_log_path
 from gausse.optim.search_space import SearchBounds, decode, genome_to_dict, sample_genome
 from gausse.physics.constants import switch_pulse_limit_a
-from gausse.sim.coilgun import CoilgunResult
 from gausse.sim.stage import build_stage_physics
 from gausse.storage.database import insert_runs, open_connection
 from gausse.storage.schema import RunRecord
 
-_FEASIBLE = CoilgunResult(feasible=True, stage_outcomes=[])
+
+@dataclass(frozen=True)
+class StagePre:
+    """Физика ступени, предвычисленная в ПЛОСКИЕ числа (пиклится дёшево).
+
+    Считается один раз на геном (в воркере пула, параллельно) через тот же
+    `build_stage_physics` — один источник истины с CPU-путём. Главному потоку
+    остаётся только склейка массивов и запуск GPU-ядер: раньше он строил
+    физобъекты 4000 геномов сам и душил GPU (карта ждала ~половину времени).
+    """
+
+    l_air_h: float
+    l_iron_coeff: float
+    coil_length_m: float
+    slug_length_m: float
+    smoothing_width_m: float
+    i_sat_a: float
+    r_total_ohm: float
+    r_eddy_coeff_ohm: float
+    retard_const_n: float
+    drag_coeff_n: float
+    capacitance_f: float
+    q0: float
+    energy_in_j: float
+    sensor_to_coil_m: float
+    fire_delay_s: float
+    sensor_kind: str
+    sensor_sens_v_per_mps: float
+    sensor_threshold_v: float
+    pulse_limit_a: float
+    degenerate_reason: str | None
+
+
+@dataclass(frozen=True)
+class GenomePre:
+    stages: tuple  # StagePre по ступеням
+    coil_centers: tuple  # абсолютные центры катушек вдоль трубы
+    mass_kg: float
+    initial_x_m: float
+    initial_v_mps: float
+
+
+def precompute_genome(genome, db: ComponentDatabase, bounds: SearchBounds) -> GenomePre:
+    """decode + build_stage_physics -> плоские числа (годится для пула процессов)."""
+    cfg, ix, iv = decode(genome, db, bounds)
+    centers = [0.0]
+    for gap in cfg.inter_stage_gaps_m:
+        centers.append(centers[-1] + gap)
+    stages = []
+    for stage in cfg.stages:
+        phys = build_stage_physics(stage, cfg.projectile)
+        m = phys.inductance_model
+        cp_ = phys.circuit_params
+        tau_worst = m.l_air_h / (phys.r_total_ohm + phys.r_eddy_coeff_ohm + 1e-12)
+        i_sat = m.saturation_current_a
+        stages.append(StagePre(
+            l_air_h=m.l_air_h,
+            l_iron_coeff=m.l_iron_coeff,
+            coil_length_m=m.coil_length_m,
+            slug_length_m=m.slug_length_m,
+            smoothing_width_m=m.smoothing_width_m,
+            i_sat_a=i_sat if math.isfinite(i_sat) else NO_SATURATION_I_SAT,
+            r_total_ohm=phys.r_total_ohm,
+            r_eddy_coeff_ohm=phys.r_eddy_coeff_ohm,
+            retard_const_n=cp_.retard_const_n,
+            drag_coeff_n=cp_.drag_coeff_n_per_mps2,
+            capacitance_f=phys.capacitance_f,
+            q0=phys.capacitance_f * stage.charge_voltage_v,
+            energy_in_j=0.5 * phys.capacitance_f * stage.charge_voltage_v**2,
+            sensor_to_coil_m=stage.sensor_to_coil_distance_m,
+            fire_delay_s=(stage.sensor.propagation_delay_ns + stage.switch.turn_on_time_ns) * 1e-9,
+            sensor_kind=stage.sensor.kind,
+            sensor_sens_v_per_mps=getattr(stage.sensor, "sensitivity_v_per_mps", None) or 0.0,
+            sensor_threshold_v=getattr(stage.sensor, "threshold_v", None) or 0.0,
+            pulse_limit_a=switch_pulse_limit_a(stage.switch),
+            degenerate_reason=(
+                "вырожденная катушка: L/R < 100 нс (вне области модели)" if tau_worst < 1e-7 else None
+            ),
+        ))
+    return GenomePre(
+        stages=tuple(stages), coil_centers=tuple(centers),
+        mass_kg=cfg.projectile.mass_kg, initial_x_m=ix, initial_v_mps=iv,
+    )
+
+
+def precompute_worker(genome) -> GenomePre:
+    """Вариант для пула (ProcessPoolExecutor c worker_context.init_worker)."""
+    from gausse.optim import worker_context
+
+    return precompute_genome(genome, worker_context.db, worker_context.bounds)
 
 
 @dataclass
 class _State:
     genome: object
-    config: object
+    pre: GenomePre
-    initial_x_m: float
-    initial_v_mps: float
-    coil_centers: list  # абсолютные центры катушек вдоль трубы
     cur_x: float  # текущая глобальная координата снаряда
     cur_v: float  # текущая скорость
     energy_in_j: float = 0.0
     kinetic_delta_j: float = 0.0
     alive: bool = True
     reason: str | None = None
+    failed_stage_index: int | None = None
 
 
 def _coast_velocity(v0: float, distance_m: float, retard_const_n: float, drag_coeff: float, mass_kg: float) -> float:
@@ -68,35 +154,151 @@ def _coast_velocity(v0: float, distance_m: float, retard_const_n: float, drag_co
     return math.sqrt(u) if u > 0 else 0.0
 
 
-def _prepare_stage(stage, projectile, cur_x_global, cur_v, coil_center_global):
+def _prepare_stage(sp: StagePre, mass_kg: float, cur_x_global, cur_v, coil_center_global):
-    """Готовит разряд ступени: физика + аналитический fire-state из текущего (x,v)."""
+    """Аналитический fire-state ступени из текущего (x,v) — только арифметика."""
     if cur_v <= 1e-6:
         return None, "снаряд остановился/пошёл назад"
-    phys = build_stage_physics(stage, projectile)
+    # вырожденный контур (см. sim/stage.py) — тот же честный быстрый отказ
-    sensor_global = coil_center_global - stage.sensor_to_coil_distance_m
+    if sp.degenerate_reason:
+        return None, sp.degenerate_reason
+    sensor_global = coil_center_global - sp.sensor_to_coil_m
     if sensor_global < cur_x_global - 1e-9:
         return None, "датчик позади снаряда (не сработает)"
     # подлёт до датчика — с трением о трубку и воздухом (та же физика, что на CPU)
-    cp_ = phys.circuit_params
     v_at_sensor = _coast_velocity(
-        cur_v, sensor_global - cur_x_global, cp_.retard_const_n, cp_.drag_coeff_n_per_mps2, projectile.mass_kg
+        cur_v, sensor_global - cur_x_global, sp.retard_const_n, sp.drag_coeff_n, mass_kg
     )
     if v_at_sensor <= 1e-3:
         return None, "снаряд остановлен трением о трубку, не долетев до датчика"
-    if stage.sensor.kind == "inductive":
+    if sp.sensor_kind == "inductive":
-        if stage.sensor.sensitivity_v_per_mps * v_at_sensor < (stage.sensor.threshold_v or 0.0):
+        if sp.sensor_sens_v_per_mps * v_at_sensor < sp.sensor_threshold_v:
             return None, "инд. датчик: сигнал ниже порога"
-    fire_delay = (stage.sensor.propagation_delay_ns + stage.switch.turn_on_time_ns) * 1e-9
+    x_fire_global = sensor_global + v_at_sensor * sp.fire_delay_s
-    x_fire_global = sensor_global + v_at_sensor * fire_delay
     x_fire_local = x_fire_global - coil_center_global
-    q0 = phys.capacitance_f * stage.charge_voltage_v
     return {
-        "phys": phys, "q0": q0, "x_fire": x_fire_local, "v_fire": v_at_sensor,
+        "sp": sp, "x_fire": x_fire_local, "v_fire": v_at_sensor,
-        "energy_in": 0.5 * phys.capacitance_f * stage.charge_voltage_v**2,
+        "coil_center": coil_center_global, "mass": mass_kg,
-        "coil_center": coil_center_global, "stage": stage, "mass": projectile.mass_kg,
     }, None
 
 
+def _simulate_states(xp, states: list) -> None:
+    """Раунд-за-раундом прогоняет разряды всех живых ступеней батчами (мутирует states)."""
+    if not states:
+        return
+    max_ns = max(len(s.pre.stages) for s in states)
+    for s_idx in range(max_ns):
+        prepared = []  # (state, prep)
+        for st in states:
+            if not st.alive or len(st.pre.stages) <= s_idx:
+                continue
+            p, reason = _prepare_stage(
+                st.pre.stages[s_idx], st.pre.mass_kg, st.cur_x, st.cur_v, st.pre.coil_centers[s_idx]
+            )
+            if p is None:
+                st.alive = False
+                st.reason = f"ступень {s_idx}: {reason}"
+                st.failed_stage_index = s_idx
+            else:
+                prepared.append((st, p))
+        if not prepared:
+            continue
+
+        def col(get):
+            return xp.asarray([get(p["sp"], p) for _, p in prepared], dtype=xp.float64)
+
+        params = BatchDischargeParams(
+            capacitance_f=col(lambda sp, p: sp.capacitance_f),
+            r_total_ohm=col(lambda sp, p: sp.r_total_ohm),
+            mass_kg=col(lambda sp, p: p["mass"]),
+            l_air_h=col(lambda sp, p: sp.l_air_h),
+            l_iron_coeff=col(lambda sp, p: sp.l_iron_coeff),
+            coil_length_m=col(lambda sp, p: sp.coil_length_m),
+            slug_length_m=col(lambda sp, p: sp.slug_length_m),
+            smoothing_width_m=col(lambda sp, p: sp.smoothing_width_m),
+            i_sat_a=col(lambda sp, p: sp.i_sat_a),
+            r_eddy_coeff_ohm=col(lambda sp, p: sp.r_eddy_coeff_ohm),
+            retard_const_n=col(lambda sp, p: sp.retard_const_n),
+            drag_coeff_n=col(lambda sp, p: sp.drag_coeff_n),
+        )
+        out = integrate_batch_discharge(
+            xp,
+            col(lambda sp, p: sp.q0),
+            col(lambda sp, p: p["x_fire"]),
+            col(lambda sp, p: p["v_fire"]),
+            params, dt=2e-6, max_steps=15000,
+        )
+        exit_v = to_cpu(xp, out["exit_v"]); exit_x = to_cpu(xp, out["exit_x"])
+        peak_i = to_cpu(xp, out["peak_current"]); feas = to_cpu(xp, out["feasible"])
+        for k, (st, p) in enumerate(prepared):
+            sp = p["sp"]
+            if not bool(feas[k]):
+                st.alive = False
+                st.reason = f"ступень {s_idx}: разряд не скоммутировался"
+                st.failed_stage_index = s_idx
+                continue
+            if float(peak_i[k]) > sp.pulse_limit_a:
+                st.alive = False
+                st.reason = f"ступень {s_idx}: пиковый ток {float(peak_i[k]):.0f}А > импульсного предела ключа ({sp.pulse_limit_a:.0f}А)"
+                st.failed_stage_index = s_idx
+                continue
+            ev = float(exit_v[k])
+            st.kinetic_delta_j += 0.5 * p["mass"] * (ev**2 - p["v_fire"] ** 2)
+            st.energy_in_j += sp.energy_in_j
+            st.cur_v = ev
+            st.cur_x = p["coil_center"] + float(exit_x[k])
+
+
+def evaluate_genomes_gpu(
+    xp, genomes: list, db: ComponentDatabase, bounds: SearchBounds, executor=None,
+) -> list:
+    """Оценка списка геномов ОДНИМ батчем (для эволюции): та же физика и та же
+    формула фитнеса, что в objective.evaluate (КПД либо -1+доля пройденных
+    ступеней), но разряды всех геномов интегрируются вместе на GPU/numpy.
+
+    Возвращает только то, что нужно фитнесу (без detail/стоимости): записи
+    для БД параллельно собирает пул процессов (`gpu_record_worker`).
+    executor — пул для ПАРАЛЛЕЛЬНОГО предвычисления физики ступеней
+    (precompute_worker): без него один поток Python готовит физику всей
+    популяции и GPU простаивает, ожидая данные.
+    """
+    from gausse.optim.objective import EvaluationResult
+
+    if executor is not None:
+        pres = list(executor.map(precompute_worker, genomes, chunksize=64))
+    else:
+        pres = [precompute_genome(g, db, bounds) for g in genomes]
+    states = [
+        _State(g, pre, cur_x=pre.initial_x_m, cur_v=pre.initial_v_mps)
+        for g, pre in zip(genomes, pres)
+    ]
+
+    _simulate_states(xp, states)
+
+    results = []
+    for st in states:
+        ok = st.alive and st.energy_in_j > 0
+        if ok:
+            eff = st.kinetic_delta_j / st.energy_in_j
+            results.append(EvaluationResult(
+                feasible=True, cost_rub=None, fitness=eff, efficiency=eff,
+                exit_velocity_mps=st.cur_v,
+                energy_breakdown={
+                    "total_energy_in_j": st.energy_in_j,
+                    "total_kinetic_energy_delta_j": st.kinetic_delta_j,
+                },
+            ))
+        else:
+            n_stages = len(st.pre.stages)
+            progress = (st.failed_stage_index or 0) / n_stages if n_stages else 0.0
+            results.append(EvaluationResult(
+                feasible=False, cost_rub=None, fitness=-1.0 + progress,
+                reason=st.reason or "нет ни одной сработавшей ступени",
+                failed_stage_index=st.failed_stage_index,
+                energy_breakdown={},
+            ))
+    return results
+
+
 def run_gpu_sweep(
     db_path: Path,
     n_runs: int,
@@ -121,55 +323,10 @@ def run_gpu_sweep(
             states = []
             for _ in range(n):
                 g = sample_genome(db, bounds, rng)
-                cfg, ix, iv = decode(g, db, bounds)
+                pre = precompute_genome(g, db, bounds)
-                centers = [0.0]
+                states.append(_State(g, pre, cur_x=pre.initial_x_m, cur_v=pre.initial_v_mps))
-                for gap in cfg.inter_stage_gaps_m:
-                    centers.append(centers[-1] + gap)
-                states.append(_State(g, cfg, ix, iv, centers, cur_x=ix, cur_v=iv))
 
-            max_ns = max(len(s.config.stages) for s in states)
+            _simulate_states(xp, states)
-            for s_idx in range(max_ns):
-                prepared = []  # (state, prep)
-                for st in states:
-                    if not st.alive or len(st.config.stages) <= s_idx:
-                        continue
-                    p, reason = _prepare_stage(
-                        st.config.stages[s_idx], st.config.projectile, st.cur_x, st.cur_v, st.coil_centers[s_idx]
-                    )
-                    if p is None:
-                        st.alive = False
-                        st.reason = f"ступень {s_idx}: {reason}"
-                    else:
-                        prepared.append((st, p))
-                if not prepared:
-                    continue
-
-                models = [p["phys"].inductance_model for _, p in prepared]
-                cps = [p["phys"].circuit_params for _, p in prepared]
-                params = params_from_models(xp, models, cps)
-                out = integrate_batch_discharge(
-                    xp,
-                    xp.asarray([p["q0"] for _, p in prepared]),
-                    xp.asarray([p["x_fire"] for _, p in prepared]),
-                    xp.asarray([p["v_fire"] for _, p in prepared]),
-                    params, dt=2e-6, max_steps=15000,
-                )
-                exit_v = to_cpu(xp, out["exit_v"]); exit_x = to_cpu(xp, out["exit_x"])
-                peak_i = to_cpu(xp, out["peak_current"]); feas = to_cpu(xp, out["feasible"])
-                for k, (st, p) in enumerate(prepared):
-                    stage = p["stage"]
-                    if not bool(feas[k]):
-                        st.alive = False; st.reason = f"ступень {s_idx}: разряд не скоммутировался"; continue
-                    surge = switch_pulse_limit_a(stage.switch)
-                    if float(peak_i[k]) > surge:
-                        st.alive = False
-                        st.reason = f"ступень {s_idx}: пиковый ток {float(peak_i[k]):.0f}А > импульсного предела ключа ({surge:.0f}А)"
-                        continue
-                    ev = float(exit_v[k])
-                    st.kinetic_delta_j += 0.5 * p["mass"] * (ev**2 - p["v_fire"] ** 2)
-                    st.energy_in_j += p["energy_in"]
-                    st.cur_v = ev
-                    st.cur_x = p["coil_center"] + float(exit_x[k])
 
             records = []
             for st in states:
@@ -190,17 +347,15 @@ def run_gpu_sweep(
 
 
 def _record(st: _State, db, backend, efficiency, exit_v):
+    from gausse.optim.objective import decoded_summary
+
     feasible = efficiency is not None
-    detail = build_detail(
-        st.config, _FEASIBLE if feasible else None, db, st.initial_x_m, st.initial_v_mps,
-        st.genome.tube_inner_d_m, st.genome.tube_wall_m,
-    )
     return RunRecord(
         run_id=str(uuid.uuid4()),
         timestamp=datetime.now(timezone.utc).isoformat(),
         search_mode=f"gpu-sweep-{backend}",
         genome_json=json.dumps(genome_to_dict(st.genome)),
-        decoded_summary_json=json.dumps(detail, ensure_ascii=False),
+        decoded_summary_json=json.dumps(decoded_summary(st.genome, db), ensure_ascii=False),
         feasible=feasible,
         model_version=MODEL_VERSION,
         infeasible_reason=st.reason,

src/gausse/optim/evolutionary.py

@@ -10,6 +10,7 @@
 import copy
 import multiprocessing
 import random
+import signal
 from concurrent.futures import ProcessPoolExecutor
 from pathlib import Path
 
@@ -18,10 +19,10 @@ from scipy.optimize import minimize
 
 from gausse.components.database import ComponentDatabase
 from gausse.optim import worker_context
-from gausse.optim.objective import EvaluationResult, build_run_record, evaluate
+from gausse.optim.objective import EvaluationResult, build_run_record, compute_cost_rub, evaluate
 from gausse.optim.progress_log import ProgressLogger, default_log_path
-from gausse.optim.search_space import Genome, SearchBounds, crossover, mutate, repair, sample_genome
+from gausse.optim.search_space import Genome, SearchBounds, crossover, decode, mutate, repair, sample_genome
-from gausse.storage.database import run_writer_process
+from gausse.storage.database import StatsOnly, insert_run, open_connection, run_writer_process
 from gausse.storage.schema import RunRecord
 
 
@@ -30,6 +31,15 @@ def _evaluate_genome(genome: Genome) -> tuple[Genome, EvaluationResult]:
     return genome, result
 
 
+def _best_record(genome: Genome, result: EvaluationResult, db, bounds, mode: str) -> RunRecord:
+    """Полная строка БД для сохраняемого лучшего генома. GPU-путь не считает
+    стоимость для рядовых оценок — дочитываем её только здесь, для избранных."""
+    if result.cost_rub is None:
+        config, _, _ = decode(genome, db, bounds)
+        result.cost_rub = compute_cost_rub(config, db)
+    return build_run_record(genome, result, db, search_mode=mode)
+
+
 def _tournament_select(
     pairs: list[tuple[Genome, EvaluationResult]], rng: random.Random, k: int = 3
 ) -> Genome:
@@ -96,13 +106,36 @@ def run_evolution(
     mutation_rate: float = 0.2,
     polish: bool = True,
     log_path: Path | None = None,
+    use_gpu: bool = False,
+    islands: int = 1,
+    migrate_every: int = 10,
 ) -> dict:
+    """islands>1 — островная модель: K независимых популяций эволюционируют
+    параллельно, а их поколения оцениваются ОДНИМ батчем (GPU любит жирные
+    батчи: на 1070 батч 4000 давал 306/с, батч 32000 — 1211/с, потому что
+    маленькие ядра упираются в накладные на запуск). Раз в migrate_every
+    поколений лучший геном каждого острова мигрирует к соседу по кольцу —
+    разнообразие против скатывания всех в один локальный оптимум.
+    """
     n_workers = n_workers or multiprocessing.cpu_count()
     rng = random.Random(seed)
     db = ComponentDatabase.load(data_dir) if data_dir else ComponentDatabase.load()
 
+    # GPU-режим: всё поколение оценивается ОДНИМ батчем (gpu/batch_sweep) —
+    # та же физика через общий build_stage_physics, фикс.шаг RK4 вместо
+    # адаптивного solve_ivp (сверено в тестах, ~3%). Полировка остаётся на CPU.
+    gpu_xp = None
+    backend = "cpu-pool"
+    if use_gpu:
+        from gausse.gpu.backend import get_backend
+
+        gpu_xp, backend = get_backend(prefer_gpu=True)
+
+    mode = "evolve" if gpu_xp is None else f"evolve-gpu({backend})"
+    if islands > 1:
+        mode += f"-x{islands}остр"
     logger = ProgressLogger(
-        log_path or default_log_path(db_path), mode="evolve", total=n_generations * population_size
+        log_path or default_log_path(db_path), mode=mode, total=n_generations * population_size * islands
     )
 
     ctx = multiprocessing.get_context("spawn")
@@ -110,29 +143,90 @@ def run_evolution(
     writer = ctx.Process(target=run_writer_process, args=(queue, db_path))
     writer.start()
 
-    population = [sample_genome(db, bounds, rng) for _ in range(population_size)]
+    # SIGTERM (остановка/рестарт systemd) -> исключение -> блок finally ниже
+    # штатно досылает None и ЖДЁТ писателя: всё уже оценённое дописывается в
+    # базу, а не теряется вместе с очередью в RAM («сохраняем всё»).
+    # ВАЖНО: после первого TERM остальные игнорируем — systemd шлёт сигнал
+    # каждому процессу группы, и повторный TERM ловился ВНУТРИ writer.join(),
+    # обрывая дописывание базы (реальный кейс с потерей хвоста очереди).
+    def _terminate(_sig, _frm):
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        raise KeyboardInterrupt("SIGTERM: дописываем очередь и выходим")
+
+    signal.signal(signal.SIGTERM, _terminate)
+
+    populations = [
+        [sample_genome(db, bounds, rng) for _ in range(population_size)] for _ in range(islands)
+    ]
     best_pair: tuple[Genome, EvaluationResult] | None = None
     n_evaluated = 0
 
     try:
+        # пул нужен в ОБОИХ режимах: на CPU он оценивает геномы, в GPU-режиме
+        # параллельно собирает записи (detail+JSON) — иначе один поток Python
+        # душит GPU (карта простаивала ~2/3 времени поколения)
         with ProcessPoolExecutor(
             max_workers=n_workers,
             mp_context=ctx,
             initializer=worker_context.init_worker,
             initargs=(data_dir, bounds),
         ) as executor:
-            for generation in range(n_generations):
+            # фитнес лучшей УЖЕ ЗАПИСАННОЙ строки каждого острова: полные
-                pairs = list(executor.map(_evaluate_genome, population))
+            # строки в базу идут только когда остров улучшился — иначе элитизм
-                n_evaluated += len(pairs)
+            # дублировал бы один и тот же геном в топ дашборда каждое поколение
+            written_best_fitness = [float("-inf")] * islands
+            # СКОРОСТЬ отслеживается отдельно: у дашборда два топа (КПД и
+            # скорость), а рекордсмены скорости — почти всегда «прожорливые»
+            # геномы с низким КПД, которые КПД-рекорд не улучшают. Без этого
+            # трекера топ скоростей замирал навсегда (реальный кейс: после
+            # перехода на выборочную запись он не обновлялся сутки, пока
+            # эволюция находила всё новые быстрые геномы)
+            written_best_velocity = [float("-inf")] * islands
 
-                for genome, result in pairs:
+            for generation in range(n_generations):
-                    record: RunRecord = build_run_record(genome, result, db, search_mode="evolve")
+                # все острова — ОДНИМ плоским батчем (жирный батч кормит GPU)
-                    queue.put(record)
+                flat = [g for island in populations for g in island]
+                if gpu_xp is not None:
+                    from gausse.gpu.batch_sweep import evaluate_genomes_gpu
+
+                    results = evaluate_genomes_gpu(gpu_xp, flat, db, bounds, executor=executor)
+                    pairs_flat = list(zip(flat, results))
+                else:
+                    pairs_flat = list(executor.map(_evaluate_genome, flat))
+                n_evaluated += len(pairs_flat)
+
+                for genome, result in pairs_flat:
                     logger.update(result.feasible, result.efficiency)
                     if best_pair is None or result.fitness > best_pair[1].fitness:
                         best_pair = (genome, result)
 
+                # селекция и скрещивание — НА КАЖДОМ ОСТРОВЕ независимо
+                island_bests: list[Genome] = []
+                next_populations = []
+                recorded = set()  # id() результатов, ушедших полной строкой
+                for i in range(islands):
+                    pairs = pairs_flat[i * population_size:(i + 1) * population_size]
                     pairs.sort(key=lambda pair: pair[1].fitness, reverse=True)
+                    island_bests.append(pairs[0][0])
+                    # улучшение лучшего на острове — полная строка в базу
+                    # (топы дашборда, best за всё время, отчёты). Новый
+                    # глобальный best — всегда чей-то островной best, так что
+                    # он не теряется.
+                    if pairs[0][1].fitness > written_best_fitness[i]:
+                        written_best_fitness[i] = pairs[0][1].fitness
+                        queue.put(_best_record(pairs[0][0], pairs[0][1], db, bounds, mode))
+                        recorded.add(id(pairs[0][1]))
+                    # рекорд СКОРОСТИ острова — тоже полной строкой
+                    fastest = max(
+                        (p for p in pairs if p[1].feasible and p[1].exit_velocity_mps is not None),
+                        key=lambda p: p[1].exit_velocity_mps,
+                        default=None,
+                    )
+                    if fastest is not None and fastest[1].exit_velocity_mps > written_best_velocity[i]:
+                        written_best_velocity[i] = fastest[1].exit_velocity_mps
+                        if id(fastest[1]) not in recorded:
+                            queue.put(_best_record(fastest[0], fastest[1], db, bounds, mode))
+                            recorded.add(id(fastest[1]))
                     next_population = [copy.deepcopy(pair[0]) for pair in pairs[:elitism]]
                     while len(next_population) < population_size:
                         parent_a = _tournament_select(pairs, rng)
@@ -140,24 +234,65 @@ def run_evolution(
                         child = crossover(parent_a, parent_b, rng)
                         child = mutate(child, db, bounds, rng, rate=mutation_rate)
                         next_population.append(child)
-                population = next_population
+                    next_populations.append(next_population)
+
+                # рядовые оценки — в базу ТОЛЬКО агрегатами (счётчики/
+                # гистограмма честно считают все оценки, вставка полной строки
+                # выше сама инкрементирует их для избранных — без двойного
+                # счёта). Хранить миллионы проходных геномов незачем
+                # («сохраняй то, что нужно для эволюции»), а вставка каждого
+                # в HDD-базу с 6 индексами была узким местом конвейера:
+                # GPU считал цикл ~23 мин, дозапись хвоста шла часами.
+                for _genome, result in pairs_flat:
+                    if id(result) not in recorded:
+                        queue.put(StatsOnly(mode, result.feasible, result.efficiency, result.reason))
+
+                # миграция по кольцу: лучший острова i замещает слот у острова i+1
+                if islands > 1 and (generation + 1) % migrate_every == 0:
+                    for i in range(islands):
+                        next_populations[(i + 1) % islands][elitism] = copy.deepcopy(island_bests[i])
+                populations = next_populations
     finally:
+        # с этого места нас нельзя прерывать: дописываем базу до конца
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
         logger.finish()
+        logger._write("дописываю хвост очереди в базу (писатель)…")
         queue.put(None)
+        while True:
+            try:
                 writer.join()
+                break
+            except KeyboardInterrupt:
+                continue  # уже завершаемся; ждём писателя до конца
+        # явно закрыть очередь: иначе её семафоры финализируются в гонке с
+        # resource_tracker на выходе интерпретатора и сыплют в журнал
+        # «Exception ignored … sem_unlink FileNotFoundError» после каждого цикла
+        queue.close()
+        queue.join_thread()
+        # после дренажа возвращаем обработку SIGTERM по умолчанию: иначе
+        # процесс в фазе полировки нельзя остановить мягко (только SIGKILL)
+        signal.signal(signal.SIGTERM, signal.SIG_DFL)
+        logger._write("база дописана полностью")
 
     assert best_pair is not None
     best_genome, best_result = best_pair
 
     if polish and best_result.feasible:
+        logger._write("полировка лучшего генома (Nelder-Mead, CPU) — это НЕ остановка, новый цикл стартует после неё")
         polished_genome, polished_result = polish_best(best_genome, db, bounds)
+        logger._write(f"полировка готова: КПД {best_result.fitness*100:.2f}% -> {polished_result.fitness*100:.2f}%")
         if polished_result.fitness > best_result.fitness:
-            conn_queue = ctx.Queue()
+            # ОДНУ запись пишем напрямую, без процесса-писателя и очереди:
-            polish_writer = ctx.Process(target=run_writer_process, args=(conn_queue, db_path))
+            # конкурентных писателей в этот момент нет (основной уже завершён),
-            polish_writer.start()
+            # а редкая гонка spawn+Queue вешала главный процесс в join()
-            conn_queue.put(build_run_record(polished_genome, polished_result, db, search_mode="evolve-polish"))
+            # НАВЕЧНО (22.5 часа простоя, пойман по /proc/*/stack: главный в
-            conn_queue.put(None)
+            # do_wait, писатель в pipe_read — данные из очереди не доехали).
-            polish_writer.join()
+            conn = open_connection(db_path)
+            try:
+                insert_run(conn, build_run_record(polished_genome, polished_result, db, search_mode="evolve-polish"))
+            finally:
+                conn.close()
+            logger._write("полированный геном записан в базу")
             best_genome, best_result = polished_genome, polished_result
 
     return {

src/gausse/optim/objective.py

@@ -21,7 +21,11 @@ from gausse.physics.inductance import air_core_inductance_wheeler, winding_geome
 from gausse.sim.coilgun import CoilgunResult, run_coilgun
 from gausse.storage.schema import RunRecord
 
-MODEL_VERSION = "gausse-physics-v2"  # v2: скин/близость (Доуэлл), трение+воздух, паспортные импульсные токи ключей
+# v4: диффузия поля в снаряд — намагничивается только скин-кольцо глубиной δ,
+# закрыт эксплойт «медленной» катушки (30%). v3: fill factor (эксплойт тонкого
+# снаряда), полное отражение вихрей, гард вырожденных катушек. v2: Доуэлл,
+# трение+воздух, паспортные импульсные токи ключей.
+MODEL_VERSION = "gausse-physics-v4"
 
 
 @dataclass
@@ -34,7 +38,6 @@ class EvaluationResult:
     efficiency: float | None = None
     exit_velocity_mps: float | None = None
     energy_breakdown: dict = None
-    detail: dict = None
 
 
 def compute_cost_rub(config, db: ComponentDatabase) -> float:
@@ -57,10 +60,11 @@ def _wire_resistance_ohm(resistivity_ohm_m: float, gauge_mm: float, wire_length_
 
 
 def decoded_summary(genome: Genome, db: ComponentDatabase) -> dict:
-    """Краткая сводка только по геному (без результатов симуляции).
+    """Краткая сводка только по геному (без результатов симуляции) — это и
-
+    пишется в decoded_summary_json для каждого прогона: genome_json уже
-    Оставлена для обратной совместимости; подробную запись со всей физикой
+    достаточен для полного воспроизведения через build_detail() на лету,
-    и результатами по каждой ступени строит `build_detail` (её и пишем в БД).
+    так что хранить дорогую подробную запись для каждого из миллионов
+    прогонов незачем (см. web/stats.run_detail для просмотра одного прогона).
     """
     material = db.projectile_materials[genome.projectile.material_idx % len(db.projectile_materials)]
     stages_summary = []
@@ -255,10 +259,15 @@ def build_detail(config, coilgun_result: CoilgunResult, db: ComponentDatabase, i
 
 
 def evaluate(genome: Genome, db: ComponentDatabase, bounds: SearchBounds) -> EvaluationResult:
+    """detail НЕ строится здесь: build_detail — дорогая (полная физика по
+    каждой ступени) и не нужна ни фитнесу, ни хранению — genome_json уже
+    достаточен, чтобы воспроизвести всё через decode()+build_detail() на
+    лету (см. web/stats.run_detail). build_run_record() кладёт в БД дешёвую
+    decoded_summary() вместо этого.
+    """
     config, initial_x_m, initial_v_mps = decode(genome, db, bounds)
     cost_rub = compute_cost_rub(config, db)
     result = run_coilgun(config)
-    detail = build_detail(config, result, db, initial_x_m, initial_v_mps, genome.tube_inner_d_m, genome.tube_wall_m)
 
     if not result.feasible:
         n_stages = len(config.stages)
@@ -271,7 +280,6 @@ def evaluate(genome: Genome, db: ComponentDatabase, bounds: SearchBounds) -> Eva
             reason=result.reason,
             failed_stage_index=result.failed_stage_index,
             energy_breakdown={},
-            detail=detail,
         )
 
     energy_breakdown = {
@@ -287,12 +295,11 @@ def evaluate(genome: Genome, db: ComponentDatabase, bounds: SearchBounds) -> Eva
         efficiency=result.efficiency,
         exit_velocity_mps=result.exit_v_mps,
         energy_breakdown=energy_breakdown,
-        detail=detail,
     )
 
 
 def build_run_record(genome: Genome, result: EvaluationResult, db: ComponentDatabase, search_mode: str) -> RunRecord:
-    detail = result.detail if result.detail is not None else decoded_summary(genome, db)
+    detail = decoded_summary(genome, db)
     return RunRecord(
         run_id=str(uuid.uuid4()),
         timestamp=datetime.now(timezone.utc).isoformat(),

src/gausse/physics/ac_resistance.py

@@ -33,6 +33,32 @@ def skin_depth_m(resistivity_ohm_m: float, omega_rad_s: float) -> float:
     return math.sqrt(2.0 * resistivity_ohm_m / (omega_rad_s * MU_0))
 
 
+def iron_penetration_fraction(
+    slug_radius_m: float,
+    slug_resistivity_ohm_m: float,
+    mu_r: float,
+    omega_rad_s: float,
+) -> float:
+    """Доля сечения снаряда, реально намагниченная за импульс (диффузия поля).
+
+    Переменное поле проникает в проводящее железо на глубину скин-слоя
+    δ = √(2ρ/(ω·μ₀·μᵣ)) — за миллисекундный импульс у стали это доли
+    миллиметра. Внутренность снаряда не успевает намагнититься и силы не
+    даёт. Работает кольцо глубиной δ: A_eff/A = 1−(1−δ/a)².
+
+    ЧЕСТНО: это одночастотная оценка (ω=1/√(LC)) решения уравнения диффузии,
+    а не само решение; ошибка — десятки процентов. Но без неё модель считала,
+    что намагничивается ВСЁ сечение, и оптимизатор строил «медленные»
+    катушки с нефизично высоким КПД (30%+).
+    """
+    if omega_rad_s <= 0 or slug_resistivity_ohm_m <= 0 or mu_r < 1 or slug_radius_m <= 0:
+        return 1.0
+    delta = math.sqrt(2.0 * slug_resistivity_ohm_m / (omega_rad_s * MU_0 * mu_r))
+    if delta >= slug_radius_m:
+        return 1.0
+    return 1.0 - (1.0 - delta / slug_radius_m) ** 2
+
+
 def dowell_ac_factor(
     wire_bare_d_m: float,
     wire_insulated_d_m: float,

src/gausse/physics/circuit.py

@@ -35,9 +35,18 @@ class StageCircuitParams:
     drag_coeff_n_per_mps2: float = 0.0
 
 
+# Сглаживание сухого трения около v=0: sign(v) -> tanh(v/ε). РАЗРЫВНАЯ сила
+# (чистый sign) ломает адаптивный решатель: у v≈0 шаг дробится бесконечно
+# (chattering), одна конфигурация считается десятки минут. tanh — стандартная
+# регуляризация (модель залипания); при |v| >> ε неотличима от sign.
+FRICTION_SMOOTHING_V_MPS = 0.01
+
+
 def retarding_force_n(params: StageCircuitParams, v: float) -> float:
-    """Тормозящая сила (трение + воздух) со знаком ПРОТИВ скорости."""
+    """Тормозящая сила (трение + воздух), гладкая по v, против скорости."""
-    return float(np.sign(v)) * (params.retard_const_n + params.drag_coeff_n_per_mps2 * v * v)
+    return float(np.tanh(v / FRICTION_SMOOTHING_V_MPS)) * (
+        params.retard_const_n + params.drag_coeff_n_per_mps2 * v * v
+    )
 
 
 def effective_resistance(inductance_model: CoilInductanceModel, params: StageCircuitParams, x) -> float:
@@ -91,3 +100,28 @@ def current_local_min_event(t: float, state: np.ndarray, inductance_model, param
 
 current_local_min_event.terminal = True
 current_local_min_event.direction = 1.0
+
+# Ток удержания ключа: тиристор сам закрывается, когда ток после пика падает
+# ниже I_H (типично 30-100 мА; берём консервативно 0.1 А). Без этого события
+# передемпфированный разряд (ток -> 0 асимптотически, нуля не пересекает)
+# заставляет решатель молотить весь временной бюджет микросекундными шагами —
+# одна конфигурация считалась минутами. Обрыв при I<I_hold — физика, не хак.
+HOLDING_CURRENT_A = 0.1
+
+
+def make_current_decay_event(i_hold_a: float = HOLDING_CURRENT_A):
+    """Терминальное событие: ток после пика упал ниже тока удержания ключа."""
+    peak = 0.0
+
+    def event(t: float, state: np.ndarray, *_args) -> float:
+        nonlocal peak
+        i = float(state[I])
+        if i > peak:
+            peak = i
+        if peak < 2.0 * i_hold_a:  # импульса ещё толком не было
+            return 1.0
+        return i - i_hold_a
+
+    event.terminal = True
+    event.direction = -1.0
+    return event

src/gausse/physics/inductance.py

@@ -107,10 +107,15 @@ class CoilInductanceModel:
     smoothing_width_m: float
     total_turns: int = 0
     b_sat_tesla: float = 1e9  # по умолчанию насыщение отключено (для геом. тестов)
+    # Доля сечения катушки, занятая железом: A_снаряда/A_среднего витка (≤1).
+    # λ = n·(B_fe·A_fe + B_возд·(A−A_fe)) ⇒ L = L_air·(1+(μ−1)·fill·overlap).
+    # БЕЗ этого тонкий снаряд в толстой катушке получал усиление как будто
+    # железо заполняет ВСЁ сечение — оптимизатор эксплуатировал (КПД «82%»).
+    iron_fill_factor: float = 1.0
 
     @property
     def l_iron_coeff(self) -> float:
-        return self.l_air_h * (self.mu_eff - 1.0)
+        return self.l_air_h * (self.mu_eff - 1.0) * self.iron_fill_factor
 
     @property
     def saturation_current_a(self) -> float:

src/gausse/physics/losses.py

@@ -46,7 +46,13 @@ def eddy_reflected_resistance_ohm(
     r_eddy_loop = 2 * math.pi * slug_resistivity_ohm_m / slug_length_m
     if r_eddy_loop <= 0:
         return 0.0
-    return (char_omega_rad_s * mutual) ** 2 / r_eddy_loop
+    # собственная индуктивность вихревого контура (виток-соленоид длиной снаряда):
+    # полная формула отражения R = (ωM)²·R₂/(R₂²+(ωL₂)²) вместо резистивно-
+    # доминированного приближения (ωM)²/R₂ — иначе на высоких ω (вырожденные
+    # короткие катушки) отражённое сопротивление нефизично улетало в сотни кОм.
+    l_eddy_loop = MU_0 * a_slug / slug_length_m
+    om = char_omega_rad_s
+    return (om * mutual) ** 2 * r_eddy_loop / (r_eddy_loop**2 + (om * l_eddy_loop) ** 2)
 
 
 def hysteresis_energy_j(slug_radius_m: float, slug_length_m: float, n_cycles: float = 1.0) -> float:

src/gausse/sim/stage.py

@@ -28,7 +28,7 @@ from gausse.physics.inductance import (
     effective_permeability,
     winding_geometry,
 )
-from gausse.physics.ac_resistance import dowell_ac_factor
+from gausse.physics.ac_resistance import dowell_ac_factor, iron_penetration_fraction
 from gausse.physics.constants import (
     AIR_DENSITY_KG_M3,
     DRAG_COEFF_CYLINDER,
@@ -122,10 +122,14 @@ def _switch_equivalent_resistance_ohm(
 
 
 def _coast_derivatives(t: float, state: np.ndarray, retard_const_n: float, drag_coeff: float, mass_kg: float) -> list[float]:
-    """Подлёт к датчику: не баллистика в вакууме, а с трением о трубку и воздухом."""
+    """Подлёт к датчику: не баллистика в вакууме, а с трением о трубку и воздухом.
+
+    Трение сглажено tanh'ом (см. circuit.FRICTION_SMOOTHING_V_MPS) — разрывный
+    sign(v) заставляет адаптивный решатель бесконечно дробить шаг у v≈0.
+    """
     v = state[1]
-    retard = retard_const_n + drag_coeff * v * v
+    retard = (retard_const_n + drag_coeff * v * v) * math.tanh(v / circuit.FRICTION_SMOOTHING_V_MPS)
-    return [v, -math.copysign(retard, v) / mass_kg if v != 0.0 else 0.0]
+    return [v, -retard / mass_kg]
 
 
 def _stall_event(t: float, state: np.ndarray, *_args) -> float:
@@ -185,6 +189,17 @@ def build_stage_physics(stage: StageConfig, projectile: ProjectileConfig) -> Sta
         coil_length_m=geometry.coil_length_m,
         char_omega_rad_s=char_omega,
     )
+    # доля сечения катушки, реально занятая железом (см. inductance.py):
+    # тонкий снаряд в толстой катушке не может усиливать ВЕСЬ поток;
+    # и из этого железа за импульс намагничивается только скин-кольцо
+    # глубиной δ (диффузия поля, см. ac_resistance.iron_penetration_fraction)
+    fill = min((projectile.diameter_m / 2) ** 2 / geometry.mean_radius_m**2, 1.0)
+    fill *= iron_penetration_fraction(
+        projectile.diameter_m / 2,
+        projectile.material.resistivity_ohm_m,
+        projectile.material.mu_r,
+        char_omega,
+    )
     inductance_model = CoilInductanceModel(
         l_air_h=l_air_h,
         coil_length_m=geometry.coil_length_m,
@@ -193,6 +208,7 @@ def build_stage_physics(stage: StageConfig, projectile: ProjectileConfig) -> Sta
         smoothing_width_m=wire_od_m,
         total_turns=geometry.total_turns,
         b_sat_tesla=projectile.material.b_sat_tesla,
+        iron_fill_factor=fill,
     )
     mass_kg = projectile.mass_kg
     frontal_area_m2 = math.pi * (projectile.diameter_m / 2) ** 2
@@ -233,6 +249,21 @@ def run_stage(
     inductance_model = phys.inductance_model
     wire_od_m = stage.wire.insulation_od_mm / 1000
 
+    # Вырожденный контур — вне области применимости модели: при постоянной
+    # времени L/R (с учётом вихревых при полном перекрытии) короче ~100 нс
+    # (например, катушка в несколько витков длиной пару мм) ОДУ становится
+    # неинтегрируемо жёсткой (решатель молотит минутами), а сама инженерная
+    # модель индуктивности/вихрей там уже не имеет смысла. Честный быстрый отказ.
+    tau_worst_s = inductance_model.l_air_h / (r_total_ohm + r_eddy_coeff + 1e-12)
+    if tau_worst_s < 1e-7:
+        return StageResult(
+            feasible=False,
+            reason=(
+                f"вырожденная катушка: постоянная времени контура {tau_worst_s*1e9:.1f} нс "
+                f"(< 100 нс) — вне области применимости модели"
+            ),
+        )
+
     x_sensor_m = -stage.sensor_to_coil_distance_m
 
     if stage.sensor.kind == "inductive":
@@ -294,13 +325,18 @@ def run_stage(
         (0.0, stage.discharge_time_budget_s),
         [q0, 0.0, x_fire_m, v_fire_mps],
         args=(inductance_model, circuit_params),
-        events=(circuit.zero_current_crossing_event, circuit.current_local_min_event),
+        events=(
+            circuit.zero_current_crossing_event,
+            circuit.current_local_min_event,
+            # ключ закрывается сам при токе ниже удержания (см. circuit.py)
+            circuit.make_current_decay_event(),
+        ),
         rtol=1e-8,
         atol=1e-11,
     )
     # какое из событий оборвало разряд первым
     term_candidates = []
-    for ev_idx in range(2):
+    for ev_idx in range(3):
         if len(discharge_sol.t_events[ev_idx]) > 0:
             term_candidates.append((discharge_sol.t_events[ev_idx][0], discharge_sol.y_events[ev_idx][0]))
     if not term_candidates:

src/gausse/storage/database.py

@@ -9,26 +9,142 @@
 
 import sqlite3
 import sys
-from dataclasses import asdict, fields
+from dataclasses import asdict, dataclass, fields
 from pathlib import Path
 
-from gausse.storage.schema import CREATE_INDEXES_SQL, CREATE_RUNS_TABLE_SQL, RunRecord
+from gausse.storage.schema import CREATE_INDEXES_SQL, CREATE_RUNS_TABLE_SQL, CREATE_STATS_SQL, RunRecord
 
 _COLUMNS = [f.name for f in fields(RunRecord)]
 
 
+@dataclass(frozen=True)
+class StatsOnly:
+    """Лёгкое сообщение писателю: учесть оценку в агрегатах дашборда
+    (счётчики/гистограмма/причины), НЕ сохраняя строку в runs.
+
+    Эволюция шлёт такое для РЯДОВЫХ геномов поколения, а полной строкой
+    пишет только улучшения лучших (см. optim/evolutionary.py): хранить
+    миллионы проходных геномов незачем, а вставка каждого в HDD-базу с
+    6 индексами была узким местом всего конвейера (GPU считал цикл за
+    ~23 мин, дозапись хвоста очереди шла часами при ~150 строк/с).
+    Атрибуты названы как у RunRecord — _apply_stats работает с обоими.
+    """
+
+    search_mode: str
+    feasible: bool
+    efficiency: float | None
+    infeasible_reason: str | None
+
+
 def open_connection(db_path: Path) -> sqlite3.Connection:
     db_path = Path(db_path)
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(db_path))
     conn.execute("PRAGMA journal_mode=WAL")
+    # не давать WAL расти безгранично: при потоке вставок 400/с и постоянных
+    # читателях (веб) авто-чекпоинт голодает, WAL раздувался до гигабайт и
+    # замедлял ВСЕ запросы. Лимит + периодический чекпоинт в писателе.
+    conn.execute("PRAGMA journal_size_limit=67108864")  # 64МБ
     conn.execute(CREATE_RUNS_TABLE_SQL)
     for statement in CREATE_INDEXES_SQL:
         conn.execute(statement)
+    for statement in CREATE_STATS_SQL:
+        conn.execute(statement)
     conn.commit()
     return conn
 
 
+def short_reason(reason: str | None) -> str | None:
+    """Причина отказа без деталей конкретного прогона (для группировки)."""
+    return reason.split(":", 1)[0] if reason else reason
+
+
+def _efficiency_bucket(efficiency: float | None) -> int | None:
+    """Корзина гистограммы КПД 0..9 (та же логика, что раньше в SQL-агрегате)."""
+    if efficiency is None:
+        return None
+    b = min(int(efficiency * 10), 9)
+    return b if 0 <= b <= 9 else None
+
+
+def _apply_stats(conn: sqlite3.Connection, records: list) -> None:
+    """Инкремент агрегатов дашборда — вызывается внутри транзакции вставки.
+
+    Принимает и RunRecord, и StatsOnly (одинаковые имена атрибутов)."""
+    n_feasible = sum(1 for r in records if r.feasible)
+    conn.execute(
+        "INSERT INTO stats_counters(key, value) VALUES('total', ?) "
+        "ON CONFLICT(key) DO UPDATE SET value = value + excluded.value",
+        (len(records),),
+    )
+    conn.execute(
+        "INSERT INTO stats_counters(key, value) VALUES('feasible', ?) "
+        "ON CONFLICT(key) DO UPDATE SET value = value + excluded.value",
+        (n_feasible,),
+    )
+    hist: dict[int, int] = {}
+    reasons: dict[str, int] = {}
+    modes: dict[str, int] = {}
+    for r in records:
+        modes[r.search_mode] = modes.get(r.search_mode, 0) + 1
+        if r.feasible:
+            b = _efficiency_bucket(r.efficiency)
+            if b is not None:
+                hist[b] = hist.get(b, 0) + 1
+        elif r.infeasible_reason:
+            key = short_reason(r.infeasible_reason)
+            reasons[key] = reasons.get(key, 0) + 1
+    conn.executemany(
+        "INSERT INTO stats_hist(bucket, count) VALUES(?, ?) "
+        "ON CONFLICT(bucket) DO UPDATE SET count = count + excluded.count",
+        list(hist.items()),
+    )
+    conn.executemany(
+        "INSERT INTO stats_reasons(reason, count) VALUES(?, ?) "
+        "ON CONFLICT(reason) DO UPDATE SET count = count + excluded.count",
+        list(reasons.items()),
+    )
+    conn.executemany(
+        "INSERT INTO stats_modes(mode, count) VALUES(?, ?) "
+        "ON CONFLICT(mode) DO UPDATE SET count = count + excluded.count",
+        list(modes.items()),
+    )
+
+
+def rebuild_stats(conn: sqlite3.Connection) -> None:
+    """Пересобирает агрегаты из таблицы runs (миграция старой базы; один раз)."""
+    conn.execute("DELETE FROM stats_counters")
+    conn.execute("DELETE FROM stats_hist")
+    conn.execute("DELETE FROM stats_reasons")
+    conn.execute("DELETE FROM stats_modes")
+    total = conn.execute("SELECT COUNT(*) FROM runs").fetchone()[0]
+    feasible = conn.execute("SELECT COUNT(*) FROM runs WHERE feasible=1").fetchone()[0]
+    conn.execute("INSERT INTO stats_counters VALUES('total', ?)", (total,))
+    conn.execute("INSERT INTO stats_counters VALUES('feasible', ?)", (feasible,))
+    conn.execute(
+        "INSERT INTO stats_hist SELECT b, COUNT(*) FROM "
+        "(SELECT MIN(CAST(efficiency*10 AS INT), 9) AS b FROM runs WHERE feasible=1 AND efficiency IS NOT NULL) "
+        "WHERE b BETWEEN 0 AND 9 GROUP BY b"
+    )
+    for reason, cnt in conn.execute(
+        "SELECT infeasible_reason, COUNT(*) FROM runs WHERE feasible=0 AND infeasible_reason IS NOT NULL "
+        "GROUP BY infeasible_reason"
+    ).fetchall():
+        conn.execute(
+            "INSERT INTO stats_reasons VALUES(?, ?) ON CONFLICT(reason) DO UPDATE SET count = count + excluded.count",
+            (short_reason(reason), cnt),
+        )
+    conn.execute("INSERT INTO stats_modes SELECT search_mode, COUNT(*) FROM runs GROUP BY search_mode")
+    conn.commit()
+
+
+def ensure_stats(conn: sqlite3.Connection) -> None:
+    """Если агрегаты пусты, а прогоны есть — база со старой схемой: пересобрать."""
+    has_stats = conn.execute("SELECT COUNT(*) FROM stats_counters").fetchone()[0] > 0
+    if not has_stats and conn.execute("SELECT EXISTS(SELECT 1 FROM runs)").fetchone()[0]:
+        rebuild_stats(conn)
+
+
 def _record_to_params(record: RunRecord) -> dict:
     row = asdict(record)
     row["feasible"] = int(row["feasible"])
@@ -45,15 +161,21 @@ def insert_run(conn: sqlite3.Connection, record: RunRecord) -> None:
     insert_runs(conn, [record])
 
 
-def insert_runs(conn: sqlite3.Connection, records: list[RunRecord]) -> None:
+def insert_runs(conn: sqlite3.Connection, records: list) -> None:
+    """Пишет пачку RunRecord/StatsOnly одной транзакцией: строки runs — только
+    для RunRecord, агрегаты дашборда — по ВСЕМ элементам пачки (либо всё,
+    либо ничего — иначе цифры на морде разъедутся с таблицей)."""
     if not records:
         return
+    rows = [r for r in records if isinstance(r, RunRecord)]
+    if rows:
         placeholders = ", ".join(f":{name}" for name in _COLUMNS)
         columns = ", ".join(_COLUMNS)
         conn.executemany(
             f"INSERT INTO runs ({columns}) VALUES ({placeholders})",
-        [_record_to_params(r) for r in records],
+            [_record_to_params(r) for r in rows],
         )
+    _apply_stats(conn, records)
     conn.commit()
 
 
@@ -81,11 +203,20 @@ def fetch_runs(
     limit: int | None = None,
 ) -> list[RunRecord]:
     conn.row_factory = sqlite3.Row
-    query = "SELECT * FROM runs WHERE 1=1"
+    # топы дашборда: принуждаем частичный DESC-индекс (INDEXED BY) — иначе
+    # планировщик берёт idx_runs_feasible и сортирует сотни тысяч строк
+    # TEMP B-TREE'ом (~2с на запрос). Условие feasible=1 обязано быть
+    # ЛИТЕРАЛОМ: частичный индекс не матчится с bound-параметром.
+    forced_index = ""
+    if feasible is True and min_efficiency is None:
+        if order_by_velocity_desc:
+            forced_index = " INDEXED BY idx_runs_feas_vel"
+        elif order_by_efficiency_desc:
+            forced_index = " INDEXED BY idx_runs_feas_eff"
+    query = f"SELECT * FROM runs{forced_index} WHERE 1=1"
     params: list = []
     if feasible is not None:
-        query += " AND feasible = ?"
+        query += f" AND feasible = {int(feasible)}"
-        params.append(int(feasible))
     if min_efficiency is not None:
         query += " AND efficiency >= ?"
         params.append(min_efficiency)
@@ -101,26 +232,67 @@ def fetch_runs(
 
 
 def run_writer_process(queue, db_path: Path) -> None:
-    """Читает `RunRecord` из очереди и пишет в SQLite, пока не придёт None.
+    """Читает `RunRecord`/`StatsOnly` из очереди и пишет в SQLite до None.
 
     Предназначен для запуска как отдельный `multiprocessing.Process` —
     единственный writer на файл базы, пока воркеры sweep/evolve только
     кладут результаты в очередь.
 
-    Один "плохой" прогон (например, коллизия run_id) не должен уронить
+    ПАЧКАМИ, не по одной: коммит SQLite = fsync (~5-10мс), и по-одному
-    писатель и остановить осушение очереди на много часов sweep — при
+    писатель выдавал ~150/с — GPU-эволюция (380+/с) копила хвост очереди в
-    ошибке вставки конкретная запись пропускается с сообщением в stderr,
+    RAM на минуты, который терялся при рестарте сервиса («сохраняем всё»
-    а не молча и не ценой падения всего процесса.
+    нарушалось). Теперь копим до BATCH записей (или пока очередь не
+    опустела) и вставляем одной транзакцией — тысячи вставок в секунду,
+    хвост исчезает.
+
+    SIGTERM игнорируется: при остановке сервиса systemd шлёт TERM всей
+    группе; писатель обязан дожить до None от главного процесса и дописать
+    ВСЁ, что уже оценено, а не умереть с полной очередью.
+
+    Одна "плохая" пачка (например, коллизия run_id) не роняет писатель:
+    откатываемся и вставляем пачку по одной, пропуская только виновника.
     """
+    import queue as queue_mod
+    import signal
+    import time as time_mod
+
+    signal.signal(signal.SIGTERM, signal.SIG_IGN)
+    BATCH = 500
+    CHECKPOINT_EVERY_S = 60.0
     conn = open_connection(db_path)
+    # если база старая (без агрегатов) — пересобрать ДО первых вставок,
+    # иначе счётчики начнут вестись только с нуля и разойдутся с таблицей
+    ensure_stats(conn)
+    last_checkpoint = time_mod.monotonic()
     try:
-        while True:
+        finished = False
-            record = queue.get()
+        while not finished:
-            if record is None:
+            batch = [queue.get()]  # блокируемся на первой
+            while len(batch) < BATCH:
+                try:
+                    batch.append(queue.get_nowait())
+                except queue_mod.Empty:
                     break
+            if batch[-1] is None:
+                finished = True
+                batch.pop()
+            if not batch:
+                continue
+            try:
+                insert_runs(conn, batch)
+            except sqlite3.Error:
+                conn.rollback()
+                for record in batch:  # ищем виновника, остальное сохраняем
                     try:
                         insert_run(conn, record)
                     except sqlite3.Error as exc:
-                print(f"[storage] не удалось записать run_id={record.run_id}: {exc}", file=sys.stderr)
+                        rid = getattr(record, "run_id", "<stats-only>")
+                        print(f"[storage] не удалось записать run_id={rid}: {exc}", file=sys.stderr)
+            # авто-чекпоинт голодает при постоянном потоке — двигаем WAL сами,
+            # PASSIVE не блокирует читателей
+            if time_mod.monotonic() - last_checkpoint > CHECKPOINT_EVERY_S:
+                conn.execute("PRAGMA wal_checkpoint(PASSIVE)")
+                last_checkpoint = time_mod.monotonic()
     finally:
+        conn.execute("PRAGMA wal_checkpoint(PASSIVE)")
         conn.close()

src/gausse/storage/schema.py

@@ -1,9 +1,18 @@
-"""Схема таблицы `runs` — ВСЕ прогоны (успешные и нет), без прикрас.
+"""Схема таблицы `runs` + агрегаты дашборда.
 
-Нереализуемые конфигурации хранятся наравне с успешными: `feasible=0` +
+Честность цифр — через агрегаты: счётчики/гистограмма/причины (stats_*)
-`infeasible_reason` с честной причиной. Ничего не отбрасывается перед
+инкрементируются для КАЖДОЙ оценки, включая нереализуемые, в той же
-записью — отбор "хороших" результатов делается запросом к этой таблице
+транзакции писателя. А вот полные СТРОКИ в `runs` пишутся по-разному:
-постфактум, а не фильтрацией на входе.
+
+- sweep/manual: каждая оценка — строка (исследовательский режим);
+- evolve (с 2026-07-12): строка — только когда лучший геном острова
+  УЛУЧШИЛСЯ (+ полировка); рядовые миллионы геномов поколения идут в базу
+  как StatsOnly-инкременты счётчиков. Хранить их незачем («сохраняй то,
+  что нужно для эволюции»), а вставка каждого в HDD-базу с 6 индексами
+  была узким местом: GPU считал цикл ~23 мин, дозапись шла часами.
+
+Нереализуемые не приукрашиваются: у строк feasible=0 + честная причина,
+у агрегатов — счётчик причин отказов.
 """
 
 from dataclasses import dataclass
@@ -14,6 +23,13 @@ CREATE TABLE IF NOT EXISTS runs (
     timestamp TEXT NOT NULL,
     search_mode TEXT NOT NULL,
     genome_json TEXT NOT NULL,
+    -- ДЕШЁВАЯ сводка (objective.decoded_summary) — НЕ полная физика по
+    -- ступеням. genome_json сам по себе достаточен, чтобы воспроизвести
+    -- всё через decode()+build_detail() на лету (см. web/stats.run_detail);
+    -- хранить дорогую детализацию для каждого из миллионов прогонов
+    -- бессмысленно — так база росла на пустом месте (70ГБ на 12.9М строк).
+    -- В базах, созданных ДО 2026-07-11, эта колонка содержит старый полный
+    -- build_detail (другая форма записей ступеней) — учитывать при чтении.
     decoded_summary_json TEXT NOT NULL,
     feasible INTEGER NOT NULL,
     infeasible_reason TEXT,
@@ -31,6 +47,21 @@ CREATE_INDEXES_SQL = [
     "CREATE INDEX IF NOT EXISTS idx_runs_efficiency ON runs(efficiency)",
     "CREATE INDEX IF NOT EXISTS idx_runs_velocity ON runs(exit_velocity_mps)",
     "CREATE INDEX IF NOT EXISTS idx_runs_search_mode ON runs(search_mode)",
+    # частичные индексы под топы дашборда: ORDER BY ... DESC при feasible=1
+    # без них top-15 на сотнях тысяч строк занимал ~1.2с на каждый рефреш
+    "CREATE INDEX IF NOT EXISTS idx_runs_feas_eff ON runs(efficiency DESC) WHERE feasible=1",
+    "CREATE INDEX IF NOT EXISTS idx_runs_feas_vel ON runs(exit_velocity_mps DESC) WHERE feasible=1",
+]
+
+# Инкрементальные агрегаты для дашборда: счётчики/гистограмма/причины/режимы
+# обновляются В ТОЙ ЖЕ транзакции, что и вставка прогонов (insert_runs), и
+# читаются за O(1) — иначе каждый рефреш морды сканировал ВСЮ таблицу runs
+# (5.2с на 630к строк, а база растёт годами).
+CREATE_STATS_SQL = [
+    "CREATE TABLE IF NOT EXISTS stats_counters (key TEXT PRIMARY KEY, value INTEGER NOT NULL)",
+    "CREATE TABLE IF NOT EXISTS stats_hist (bucket INTEGER PRIMARY KEY, count INTEGER NOT NULL)",
+    "CREATE TABLE IF NOT EXISTS stats_reasons (reason TEXT PRIMARY KEY, count INTEGER NOT NULL)",
+    "CREATE TABLE IF NOT EXISTS stats_modes (mode TEXT PRIMARY KEY, count INTEGER NOT NULL)",
 ]
 
 

src/gausse/web/page.py

@@ -60,7 +60,9 @@ PAGE_HTML = r"""<!doctype html>
     <div class="card"><div class="k">Реализуемо</div><div class="v" id="c-feas">—</div></div>
     <div class="card"><div class="k">Нереализуемо</div><div class="v" id="c-infeas">—</div></div>
     <div class="card"><div class="k">Доля реализуемых</div><div class="v" id="c-pct">—</div></div>
-    <div class="card"><div class="k">Лучший КПД / скорость</div><div class="v" id="c-best" style="font-size:20px">—</div></div>
+    <div class="card"><div class="k">Лучший КПД за всё время / скорость</div><div class="v" id="c-best" style="font-size:20px">—</div></div>
+    <div class="card"><div class="k">Лучший КПД текущего цикла</div><div class="v" id="c-cycle" style="font-size:20px">—</div></div>
+    <div class="card"><div class="k">GPU (GTX 1070)</div><div class="v" id="c-gpu" style="font-size:20px">—</div></div>
   </div>
 
   <div class="grid2">
@@ -70,7 +72,7 @@ PAGE_HTML = r"""<!doctype html>
         <button class="tgl" id="tab-vel" onclick="setRank('vel')">по скорости</button>
       </h2>
       <table>
-        <thead><tr><th>КПД</th><th>Скор., м/с</th><th>Ступ.</th><th>Цена, ₽</th><th>Режим</th></tr></thead>
+        <thead><tr><th>КПД</th><th>Скор., м/с</th><th>Ступ.</th><th>Цена, ₽</th><th>Режим</th><th>Когда найден</th></tr></thead>
         <tbody id="top"></tbody>
       </table>
       <p class="muted" style="font-size:12px">Клик по строке — полная детализация прогона (расстояния, номиналы, физика).</p>
@@ -107,13 +109,23 @@ function setRank(m){ rankMode=m; if(lastOverview) renderTop(lastOverview);
   document.getElementById('tab-eff').classList.toggle('active', m==='eff');
   document.getElementById('tab-vel').classList.toggle('active', m==='vel'); }
 
+// «Когда найден»: без этой колонки обновление топа было НЕВИДИМО — новая
+// строка 13.63% глазом неотличима от старой 13.44%, и казалось, что таблица
+// застыла. Свежие записи (< 1 часа) подсвечиваются.
+const fmtWhen = ts => {
+  if(!ts) return "—";
+  const d = new Date(ts), ageMs = Date.now()-d.getTime();
+  const t = d.toLocaleString([], {day:'2-digit',month:'2-digit',hour:'2-digit',minute:'2-digit'});
+  return ageMs < 3600e3 ? `<b style="color:#3fb950">${t}</b>` : t;
+};
 function renderTop(o){
   const rows = rankMode==='vel' ? (o.top_by_velocity||[]) : (o.top||[]);
   const top = document.getElementById('top'); top.innerHTML='';
   rows.forEach(t=>{
     const tr=document.createElement('tr'); tr.className='clk';
     tr.innerHTML=`<td>${fmtPct(t.efficiency)}</td><td>${fmt(t.exit_velocity_mps,1)}</td>`+
-      `<td>${t.n_stages??'—'}</td><td>${fmt(t.cost_rub,0)}</td><td><span class="pill">${t.search_mode}</span></td>`;
+      `<td>${t.n_stages??'—'}</td><td>${fmt(t.cost_rub,0)}</td><td><span class="pill">${t.search_mode}</span></td>`+
+      `<td class="muted" style="white-space:nowrap">${fmtWhen(t.timestamp)}</td>`;
     tr.onclick=()=>showDetail(t.run_id);
     top.appendChild(tr);
   });
@@ -131,6 +143,12 @@ async function refresh(){
     let best = (o.top && o.top.length) ? o.top[0].efficiency : null;
     let bestV = (o.top_by_velocity && o.top_by_velocity.length) ? o.top_by_velocity[0].exit_velocity_mps : null;
     document.getElementById('c-best').textContent = fmtPct(best) + (bestV!=null ? ' / '+fmt(bestV,0)+' м/с' : '');
+    document.getElementById('c-cycle').textContent =
+      o.cycle_best_pct==null ? '—' : o.cycle_best_pct.toFixed(2)+'% (цикл идёт)';
+    const g = o.gpu;
+    document.getElementById('c-gpu').textContent = g
+      ? `${g.util_pct}% · ${fmt(g.power_w,0)}Вт · ${g.temp_c}°C`
+      : 'нет данных';
     renderTop(o);
 
     const hist=document.getElementById('hist'); hist.innerHTML='';

src/gausse/web/rebuild.py

@@ -0,0 +1,60 @@
+"""Восстановление симуляции прогона из genome_json — ОДИН общий путь для
+детализации (stats.run_detail) и рендера графиков/анимации (render.py).
+
+Раньше эти два места дублировали decode()+run_coilgun() независимо, причём
+каждый клик по прогону запускал одну и ту же симуляцию до 5 раз (детализация
++ 3 графика + GIF), а run_detail ещё и перечитывал базу компонентов с диска
+на каждый запрос. Здесь: кэш базы компонентов + маленький кэш последних
+симуляций по run_id.
+"""
+
+import json
+import threading
+from pathlib import Path
+
+from gausse.components.database import ComponentDatabase
+from gausse.optim.search_space import SearchBounds, decode, genome_from_dict
+from gausse.sim.coilgun import run_coilgun
+from gausse.storage.database import fetch_run_by_id, open_connection
+
+_db_cache: ComponentDatabase | None = None
+_sim_lock = threading.Lock()
+_sim_cache: dict[str, tuple] = {}  # run_id -> (row, genome, config, result, x0, v0)
+_SIM_CACHE_MAX = 8  # клик по прогону = detail + 3 графика + GIF того же run_id
+
+
+def components_db() -> ComponentDatabase:
+    global _db_cache
+    if _db_cache is None:
+        _db_cache = ComponentDatabase.load()
+    return _db_cache
+
+
+def rebuild_run(db_path: Path, run_id: str):
+    """(row, genome, config, result, initial_x_m, initial_v_mps) либо None,
+    если run_id нет в базе. Ошибки пересимуляции пробрасываются наружу —
+    вызывающий решает, что показать (детализация не должна ронять сервер).
+    """
+    with _sim_lock:
+        cached = _sim_cache.get(run_id)
+    if cached is not None:
+        return cached
+
+    conn = open_connection(db_path)
+    try:
+        row = fetch_run_by_id(conn, run_id)
+    finally:
+        conn.close()
+    if row is None:
+        return None
+
+    genome = genome_from_dict(json.loads(row.genome_json))
+    config, initial_x_m, initial_v_mps = decode(genome, components_db(), SearchBounds())
+    result = run_coilgun(config)
+
+    entry = (row, genome, config, result, initial_x_m, initial_v_mps)
+    with _sim_lock:
+        if len(_sim_cache) >= _SIM_CACHE_MAX:
+            _sim_cache.clear()
+        _sim_cache[run_id] = entry
+    return entry

src/gausse/web/render.py

@@ -7,7 +7,6 @@
 """
 
 import io
-import json
 import tempfile
 import threading
 from pathlib import Path
@@ -18,15 +17,11 @@ matplotlib.use("Agg")
 
 import matplotlib.pyplot as plt
 
-from gausse.components.database import ComponentDatabase
-from gausse.optim.search_space import SearchBounds, decode, genome_from_dict
 from gausse.report.animate import animate_run
 from gausse.report.plots import plot_stage_currents, plot_stage_fields, plot_velocity_vs_position
-from gausse.sim.coilgun import run_coilgun
+from gausse.web.rebuild import rebuild_run
-from gausse.storage.database import fetch_run_by_id, open_connection
 
 _render_lock = threading.Lock()
-_db_cache: ComponentDatabase | None = None
 
 _PLOT_BUILDERS = {
     "velocity": plot_velocity_vs_position,
@@ -35,24 +30,12 @@ _PLOT_BUILDERS = {
 }
 
 
-def _components_db() -> ComponentDatabase:
-    global _db_cache
-    if _db_cache is None:
-        _db_cache = ComponentDatabase.load()
-    return _db_cache
-
-
 def _rebuild_result(db_path: Path, run_id: str):
-    conn = open_connection(db_path)
+    rebuilt = rebuild_run(db_path, run_id)  # общий кэш симуляций с run_detail
-    try:
+    if rebuilt is None:
-        row = fetch_run_by_id(conn, run_id)
-    finally:
-        conn.close()
-    if row is None:
         return None
-    genome = genome_from_dict(json.loads(row.genome_json))
+    _row, _genome, config, result, _ix, _iv = rebuilt
-    config, _ix, _iv = decode(genome, _components_db(), SearchBounds())
+    return config, result
-    return config, run_coilgun(config)
 
 
 def render_plot_png(db_path: Path, run_id: str, kind: str) -> bytes | None:

src/gausse/web/stats.py

@@ -1,57 +1,85 @@
 """Агрегаты по таблице `runs` для веб-морды — считаются запросами к SQLite."""
 
 import json
+import time
 from pathlib import Path
 
-from gausse.storage.database import fetch_run_by_id, fetch_runs, open_connection
+from gausse.storage.database import ensure_stats, fetch_run_by_id, fetch_runs, open_connection
 
 
 def _tail_log(log_path: Path, n_lines: int = 40) -> list[str]:
+    """Последние строки лога чтением С КОНЦА файла (лог растёт годами —
+    перечитывать его целиком на каждый рефреш нельзя)."""
     if not log_path.exists():
         return []
-    lines = log_path.read_text(encoding="utf-8", errors="replace").splitlines()
+    with open(log_path, "rb") as f:
+        f.seek(0, 2)
+        size = f.tell()
+        f.seek(max(0, size - 64 * 1024))
+        chunk = f.read().decode("utf-8", errors="replace")
+    lines = chunk.splitlines()
+    if size > 64 * 1024 and lines:
+        lines = lines[1:]  # первая строка чанка может быть обрезана
     return lines[-n_lines:]
 
 
+def _gpu_stat(db_path: Path) -> dict | None:
+    """Загрузка GPU из gpustat.json рядом с базой (пишет gausse-gpustat на хосте).
+
+    Веб живёт в Docker без доступа к nvidia-smi, поэтому хост-сервис раз в
+    несколько секунд кладёт JSON в каталог результатов. Протухшие данные
+    (>30с — писатель умер/GPU нет) честно не показываем.
+    """
+    p = db_path.parent / "gpustat.json"
+    try:
+        stat = json.loads(p.read_text(encoding="utf-8"))
+        if time.time() - float(stat.get("ts", 0)) > 30:
+            return None
+        return stat
+    except (OSError, ValueError):
+        return None
+
+
 def overview(db_path: Path, log_path: Path | None = None, top_n: int = 15) -> dict:
-    """Сводка для дашборда: счётчики, гистограмма КПД, топ конфигураций, хвост лога."""
+    """Сводка для дашборда: счётчики, гистограмма КПД, топ конфигураций, хвост лога.
+
+    Счётчики/гистограмма/причины/режимы читаются из инкрементальных
+    агрегатов (stats_*, ведутся в транзакции вставки) за O(1) — раньше
+    каждый рефреш сканировал всю таблицу runs (5.2с на 630к строк).
+    """
     conn = open_connection(db_path)
     try:
-        total = conn.execute("SELECT COUNT(*) FROM runs").fetchone()[0]
+        ensure_stats(conn)  # миграция базы со старой схемой (один раз)
-        feasible = conn.execute("SELECT COUNT(*) FROM runs WHERE feasible=1").fetchone()[0]
+        counters = dict(conn.execute("SELECT key, value FROM stats_counters"))
+        total = counters.get("total", 0)
+        feasible = counters.get("feasible", 0)
         infeasible = total - feasible
 
-        # распределение по типу датчика ступени 0 (реализуемо / всего)
+        by_mode = dict(conn.execute("SELECT mode, count FROM stats_modes"))
-        by_mode = {}
-        for mode, cnt in conn.execute("SELECT search_mode, COUNT(*) FROM runs GROUP BY search_mode"):
-            by_mode[mode] = cnt
 
-        # причины отказа (топ)
+        reasons = [
-        reasons = []
+            {"reason": reason, "count": cnt}
             for reason, cnt in conn.execute(
-            "SELECT infeasible_reason, COUNT(*) c FROM runs WHERE feasible=0 AND infeasible_reason IS NOT NULL "
+                "SELECT reason, count FROM stats_reasons ORDER BY count DESC LIMIT 10"
-            "GROUP BY infeasible_reason ORDER BY c DESC LIMIT 10"
+            )
-        ):
+        ]
-            short = reason.split(":", 1)[0] if reason else reason
-            reasons.append({"reason": short, "count": cnt})
 
-        # гистограмма КПД — агрегируем в SQL (не тянем все строки в питон)
         buckets = [0] * 10  # 0-10%,...,90-100%
-        for bucket, cnt in conn.execute(
+        for bucket, cnt in conn.execute("SELECT bucket, count FROM stats_hist"):
-            "SELECT MIN(CAST(efficiency*10 AS INT), 9) AS b, COUNT(*) FROM runs "
+            if 0 <= bucket <= 9:
-            "WHERE feasible=1 AND efficiency IS NOT NULL GROUP BY b"
-        ):
-            if bucket is not None and 0 <= bucket <= 9:
                 buckets[int(bucket)] = cnt
 
         def _summarize(rows):
             out = []
             for r in rows:
-                detail = json.loads(r.decoded_summary_json) if r.decoded_summary_json else {}
+                summary = json.loads(r.decoded_summary_json) if r.decoded_summary_json else {}
+                stages = summary.get("stages")
                 out.append({
                     "run_id": r.run_id, "search_mode": r.search_mode, "efficiency": r.efficiency,
                     "exit_velocity_mps": r.exit_velocity_mps, "cost_rub": r.cost_rub,
-                    "n_stages": detail.get("n_stages"), "timestamp": r.timestamp,
+                    # None (не 0), когда сводки нет — морда покажет «—»
+                    "n_stages": len(stages) if stages is not None else None,
+                    "timestamp": r.timestamp,
                 })
             return out
 
@@ -70,27 +98,70 @@ def overview(db_path: Path, log_path: Path | None = None, top_n: int = 15) -> di
         "efficiency_histogram": buckets,
         "top": top,
         "top_by_velocity": top_by_velocity,
-        "log_tail": _tail_log(log_path, 40) if log_path else [],
+        "log_tail": (tail := _tail_log(log_path, 40) if log_path else []),
+        # лучший КПД ТЕКУЩЕГО цикла (из лога): каждый цикл стартует со свежей
+        # популяции и карабкается заново — это ДРУГОЕ число, чем best за всё
+        # время, и без подписи их путали («сервер и морда не связаны»)
+        "cycle_best_pct": _last_cycle_best(tail),
+        "gpu": _gpu_stat(db_path),
     }
 
 
+def _last_cycle_best(log_lines: list[str]) -> float | None:
+    import re
+
+    for line in reversed(log_lines):
+        m = re.search(r"лучший_КПД=(-?[0-9.]+)%", line)
+        if m:
+            return float(m.group(1))
+    return None
+
+
 def run_detail(db_path: Path, run_id: str) -> dict | None:
+    """Подробности одного прогона. Шапка (feasible/КПД/скорость/энергобаланс)
+    — СОХРАНЁННЫЕ при прогоне значения: они посчитаны тем движком и той
+    версией физики, что записали строку, и только они сравнимы между собой.
+    Полная физика по ступеням в БД не хранится (см. schema.py) — она
+    пересимулируется на лету из genome_json через общий web/rebuild.py.
+    Пересчёт идёт ТЕКУЩЕЙ моделью на CPU и может расходиться с сохранёнными
+    числами (GPU-строки, старые model_version) — поэтому detail явно помечен
+    версией пересчёта, а его ошибка не роняет запрос (раньше /api/run был
+    единственным эндпоинтом без защиты)."""
+    from gausse.optim.objective import MODEL_VERSION, build_detail
+
+    from gausse.web.rebuild import components_db, rebuild_run
+
     conn = open_connection(db_path)
     try:
         row = fetch_run_by_id(conn, run_id)
+    finally:
+        conn.close()
     if row is None:
         return None
+
+    try:
+        _, genome, config, result, initial_x_m, initial_v_mps = rebuild_run(db_path, run_id)
+        detail = build_detail(
+            config, result, components_db(), initial_x_m, initial_v_mps,
+            genome.tube_inner_d_m, genome.tube_wall_m,
+        )
+        detail["recomputed_with_model_version"] = MODEL_VERSION
+    except Exception as exc:  # деталь — вспомогательная, шапка важнее
+        detail = {"error": f"пересимуляция не удалась: {exc}"}
+
     return {
         "run_id": row.run_id,
         "search_mode": row.search_mode,
+        # версия физики обязана быть видна: прогоны разных моделей
+        # несравнимы, и «лучший» старой версии — не лучший вообще
+        "model_version": row.model_version,
         "feasible": row.feasible,
         "infeasible_reason": row.infeasible_reason,
         "efficiency": row.efficiency,
         "exit_velocity_mps": row.exit_velocity_mps,
         "cost_rub": row.cost_rub,
         "timestamp": row.timestamp,
-            "detail": json.loads(row.decoded_summary_json) if row.decoded_summary_json else {},
+        "detail": detail,
+        # сохранённый при записи баланс — консистентен с feasible/КПД шапки
         "energy_breakdown": json.loads(row.energy_breakdown_json) if row.energy_breakdown_json else {},
     }
-    finally:
-        conn.close()

tests/test_evolutionary.py

@@ -8,7 +8,14 @@ from gausse.storage.database import count_runs, fetch_runs, open_connection
 DB = ComponentDatabase.load()
 
 
-def test_run_evolution_writes_all_evaluations_and_returns_summary(tmp_path):
+def _stats_total(conn) -> int:
+    row = conn.execute("SELECT value FROM stats_counters WHERE key='total'").fetchone()
+    return row[0] if row else 0
+
+
+def test_run_evolution_counts_all_evaluations_but_stores_only_best_rows(tmp_path):
+    """Контракт хранения evolve: агрегаты честно считают ВСЕ оценки,
+    а полные строки — только улучшения лучшего генома острова."""
     db_path = tmp_path / "runs.sqlite3"
     bounds = SearchBounds(max_stages=2)
 
@@ -26,9 +33,17 @@ def test_run_evolution_writes_all_evaluations_and_returns_summary(tmp_path):
     assert "best_fitness" in summary
 
     conn = open_connection(db_path)
-    assert count_runs(conn) == 12
+    assert _stats_total(conn) == 12  # счётчики дашборда видят все оценки
+    n_rows = count_runs(conn)
+    # строк меньше, чем оценок: максимум 2 улучшения (КПД+скорость) на
+    # остров на поколение
+    assert 1 <= n_rows <= 4
     rows = fetch_runs(conn)
     assert all(r.search_mode == "evolve" for r in rows)
+    # лучший найденный обязан лежать в базе полной строкой
+    best_row_fitness = max((r.efficiency if r.feasible else -1.0) for r in rows)
+    if summary["best_feasible"]:
+        assert best_row_fitness == summary["best_efficiency"]
     conn.close()
 
 
@@ -63,3 +78,40 @@ def test_polish_does_not_make_the_best_genome_worse():
 
     _, polished_result = polish_best(genome, DB, bounds)
     assert polished_result.fitness >= baseline_fitness - 1e-9
+
+
+def test_run_evolution_gpu_batch_mode(tmp_path):
+    """GPU-режим эволюции (батч-оценка поколения; здесь numpy-бэкенд):
+    агрегаты считают все оценки, строки — только улучшения лучшего."""
+    from gausse.storage.database import count_runs, fetch_runs, open_connection
+
+    db_path = tmp_path / "evo_gpu.sqlite3"
+    summary = run_evolution(
+        db_path, n_generations=3, population_size=40, seed=5, polish=False, use_gpu=True
+    )
+    assert summary["n_evaluated"] == 120
+    conn = open_connection(db_path)
+    assert _stats_total(conn) == 120
+    # 1 остров x 3 поколения, максимум 2 улучшения (КПД+скорость) за поколение
+    assert 1 <= count_runs(conn) <= 6
+    rows = fetch_runs(conn, limit=5)
+    assert all(r.search_mode.startswith("evolve-gpu") for r in rows)
+    # у сохранённых лучших должна быть посчитана стоимость (GPU-путь
+    # не считает её для рядовых, но дочитывает для избранных)
+    assert all(r.cost_rub is not None for r in rows)
+
+
+def test_run_evolution_islands(tmp_path):
+    """Островная модель: K популяций одним батчем + миграция по кольцу."""
+    from gausse.storage.database import count_runs, open_connection
+
+    db_path = tmp_path / "evo_isl.sqlite3"
+    summary = run_evolution(
+        db_path, n_generations=4, population_size=15, seed=7, polish=False,
+        use_gpu=True, islands=3, migrate_every=2,
+    )
+    assert summary["n_evaluated"] == 4 * 15 * 3
+    conn = open_connection(db_path)
+    assert _stats_total(conn) == 4 * 15 * 3
+    # максимум 2 улучшения (КПД+скорость) на остров на поколение
+    assert 3 <= count_runs(conn) <= 4 * 3 * 2

tests/test_realism_v2.py

@@ -145,3 +145,94 @@ def test_pulse_limit_fallback_without_datasheet():
     sw = replace(DB.switches[0], pulse_current_a=None)
     # без даташита — консервативный множитель по типу ключа
     assert switch_pulse_limit_a(sw) == sw.max_current_a * {"SCR": 10.0, "MOSFET": 4.0, "IGBT": 3.0}[sw.kind]
+
+
+def test_friction_force_smooth_at_zero_velocity():
+    """Регрессия на завис решателя: сила трения обязана быть ГЛАДКОЙ в v=0.
+
+    Разрывный sign(v) заставлял solve_ivp бесконечно дробить шаг у v≈0
+    (одна конфигурация считалась 35+ минут на сервере).
+    """
+    from gausse.physics.circuit import StageCircuitParams, retarding_force_n
+
+    p = StageCircuitParams(
+        capacitance_f=1e-4, r_total_ohm=0.1, mass_kg=0.01,
+        retard_const_n=0.034, drag_coeff_n_per_mps2=2e-5,
+    )
+    # непрерывность: около нуля сила ~ 0, нечётная, без скачка
+    assert abs(retarding_force_n(p, 1e-6)) < 1e-5
+    assert abs(retarding_force_n(p, 1e-6) + retarding_force_n(p, -1e-6)) < 1e-12
+    # вдали от нуля выходит на полное трение
+    assert retarding_force_n(p, 1.0) > 0.9 * p.retard_const_n
+
+
+def test_iron_fill_factor_punishes_thin_slug_in_fat_coil():
+    """Регрессия на эксплойт «КПД 82%»: тонкий снаряд в толстой катушке
+    не может усиливать весь поток — только долю сечения, которую занимает."""
+    from gausse.physics.inductance import CoilInductanceModel
+
+    base = dict(l_air_h=1e-3, coil_length_m=0.05, slug_length_m=0.02,
+                mu_eff=40.0, smoothing_width_m=0.001, total_turns=300)
+    full = CoilInductanceModel(**base, iron_fill_factor=1.0)
+    thin = CoilInductanceModel(**base, iron_fill_factor=0.02)  # ⌀4мм в ⌀29мм
+    # сила при том же токе в 50 раз меньше — халявы больше нет
+    f_full = float(full.force_newtons(-0.03, 100.0))
+    f_thin = float(thin.force_newtons(-0.03, 100.0))
+    assert f_thin < 0.03 * f_full
+
+
+def test_degenerate_coil_fails_fast():
+    """Регрессия на завис 540с: вырожденная катушка бракуется мгновенно."""
+    import time
+    from dataclasses import replace
+
+    stage = make_stage()
+    degenerate = replace(stage, turns_per_layer=2, layers=2)  # 4 витка, ~2мм
+    t0 = time.time()
+    res = run_stage(-0.06, 3.0, degenerate, make_projectile())
+    assert time.time() - t0 < 5.0, "вырожденный конфиг должен отваливаться быстро"
+    # либо честно отбракован гардом, либо честно посчитан быстро — оба исхода ок
+    if not res.feasible:
+        assert res.reason
+
+
+def test_eddy_reflection_bounded_at_high_frequency():
+    """Полная формула отражения (R₂²+(ωL₂)² в знаменателе): на высоких ω
+    заметно ниже старого резистивно-доминированного приближения, на низких —
+    сходится к нему. Совсем вырожденные катушки добивает гард L/R в run_stage."""
+    import math as _m
+
+    from gausse.physics.constants import MU_0
+    from gausse.physics.losses import EDDY_COUPLING_FACTOR, eddy_reflected_resistance_ohm
+
+    kwargs = dict(slug_radius_m=0.002, slug_length_m=0.03,
+                  slug_resistivity_ohm_m=1.6e-7, mu_eff=259.0,
+                  total_turns=5, coil_length_m=0.002)
+
+    def resistive_approx(om):
+        a = _m.pi * kwargs["slug_radius_m"] ** 2
+        m = EDDY_COUPLING_FACTOR * MU_0 * kwargs["mu_eff"] * (5 / 0.002) * a
+        r2 = 2 * _m.pi * kwargs["slug_resistivity_ohm_m"] / kwargs["slug_length_m"]
+        return (om * m) ** 2 / r2
+
+    om_hi, om_lo = 1.25e5, 1e2
+    r_hi = eddy_reflected_resistance_ohm(**kwargs, char_omega_rad_s=om_hi)
+    r_lo = eddy_reflected_resistance_ohm(**kwargs, char_omega_rad_s=om_lo)
+    assert r_hi < 0.5 * resistive_approx(om_hi)  # высокие ω: ограничена
+    assert abs(r_lo - resistive_approx(om_lo)) < 0.05 * resistive_approx(om_lo)  # низкие: сходится
+
+
+def test_iron_penetration_fraction_limits():
+    """Диффузия поля: тонкий снаряд/медленный импульс — всё сечение; толстый
+    снаряд на быстром импульсе — только скин-кольцо (эксплойт «30%» закрыт)."""
+    from gausse.physics.ac_resistance import iron_penetration_fraction
+
+    # очень низкая частота: поле успевает пропитать всё сечение
+    assert iron_penetration_fraction(0.005, 1.4e-7, 500.0, 1.0) == 1.0
+    # сталь ⌀9.3мм на ω~1350 рад/с (медленная катушка из эксплойта):
+    # намагничивается лишь внешнее кольцо — заметно меньше половины сечения
+    frac = iron_penetration_fraction(0.00465, 1.4e-7, 500.0, 1350.0)
+    assert 0.02 < frac < 0.5
+    # быстрее импульс -> тоньше кольцо (монотонность по ω)
+    frac_fast = iron_penetration_fraction(0.00465, 1.4e-7, 500.0, 13500.0)
+    assert frac_fast < frac

tests/test_storage_database.py

@@ -99,6 +99,36 @@ def test_writer_survives_duplicate_run_id_and_keeps_draining_queue(tmp_path):
     conn.close()
 
 
+def test_writer_stats_only_bumps_counters_without_rows(tmp_path):
+    """StatsOnly-сообщения (эволюция шлёт их для рядовых геномов): агрегаты
+    дашборда растут, а строк в runs не появляется."""
+    from gausse.storage.database import StatsOnly
+
+    db_path = tmp_path / "runs.sqlite3"
+    ctx = multiprocessing.get_context("spawn")
+    queue = ctx.Queue()
+
+    writer = ctx.Process(target=run_writer_process, args=(queue, db_path))
+    writer.start()
+
+    queue.put(_record("best-one"))  # одна полная строка
+    queue.put(StatsOnly("evolve", True, 0.42, None))
+    queue.put(StatsOnly("evolve", False, None, "датчик: сигнал ниже порога"))
+    queue.put(StatsOnly("evolve", False, None, None))
+    queue.put(None)
+    writer.join(timeout=10)
+
+    assert not writer.is_alive()
+    conn = open_connection(db_path)
+    assert count_runs(conn) == 1  # строка только у полной записи
+    counters = dict(conn.execute("SELECT key, value FROM stats_counters"))
+    assert counters["total"] == 4  # но посчитаны все четыре
+    assert counters["feasible"] == 2
+    reasons = dict(conn.execute("SELECT reason, count FROM stats_reasons"))
+    assert reasons.get("датчик") == 1
+    conn.close()
+
+
 def _writer_worker(queue, worker_id, n):
     for i in range(n):
         queue.put(_record(f"proc-{worker_id}-run-{i}"))