fix(core): ходить в CORE через sing-box — с российских адресов ключ не работает

Заливка встала после двух порций: прогоны стали заканчиваться за две минуты
с нулём документов. Выглядело как поломка сети, и на ложные следы ушло время —
MTU в норме (1472 байта проходят), IPv6 ни при чём, Cloudflare из того же
контейнера качается на 2.2 МБ/с, ключ и квота целы (с домашней машины тот же
запрос отвечает за 6с, лимит нетронут).

Разница оказалась в адресе. С прода:
  напрямую      — код 000, обрыв на 25с (соединение есть, тело не приходит)
  через sing-box — код 200 за 1.7с, 207 КБ
Анонимные короткие запросы проходят и напрямую — поэтому блокировка и
маскировалась под сетевой сбой.

CORE ведёт себя как OpenRouter, ради которого singbox-proxy и заводили,
поэтому решение то же: httpx получает proxy из CORE_PROXY_URL (умолчание —
socks5://singbox-proxy:1080, пусто = напрямую для локальных прогонов).
В образ индексатора добавлен socksio: без него httpx не умеет SOCKS5.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

README.md

@@ -23,7 +23,7 @@
                        │ RabbitMQ│ Celery задачи
           ┌────────────▼──┐  ┌──▼──────────────┐
           │  worker-gpu    │  │ worker-indexer   │
-          │  (CUDA/FAISS)  │  │ (PDF/DOCX parse) │
+          │  (FAISS, CPU)  │  │ (PDF/DOCX parse) │
           │  Sem. search   │  │ Winnowing/MinHash │
           │  LLM paraphrase│  └──────────────────┘
           └────────────────┘
@@ -35,7 +35,8 @@
 
 Инфраструктура:
   PostgreSQL 16 · Redis 7 · RabbitMQ 3 · Elasticsearch 8
-  MinIO (S3) · Ollama (qwen2.5:7b) · отдельный GPU-сервер
+  MinIO (S3) · Ollama с bge-m3 на отдельном сервере эмбеддингов (192.168.1.40)
+  LLM-парафраз (L4) — Ollama или OpenRouter, переключается LLM_BACKEND
 ```
 
 ## Быстрый старт
@@ -232,7 +233,7 @@ docker compose -f docker-compose.prod.yml --profile observability up -d promethe
 
 1. **Линт** — `ruff` (весь Python) + `mypy` (чистая доменная логика).
    Конфиги: [`ruff.toml`](ruff.toml), [`mypy.ini`](mypy.ini).
-2. **Юнит-тесты** — `pytest` по сервисам: 132 теста на ядро детекции, скоринга,
+2. **Юнит-тесты** — `pytest` по сервисам: 150 тестов на ядро детекции, скоринга,
    парсеров, форматирования, OAuth и прогресса заливки, без внешней инфры
    (БД/Redis/GPU/Ollama замоканы либо не нужны).
 
@@ -265,7 +266,7 @@ make test-one SVC=worker-gost    # тесты одного сервиса
 | Парсеры источников (CyberLeninka, PMC, прогресс-колбэк) | `scripts/parsers/` | 19 |
 | OAuth-ссылки (Google/Яндекс) | `api/app/core/oauth.py` | 6 |
 | Прогресс заливки (счётчики, бюджет) | `worker-indexer/app/progress.py` | 7 |
-| Шкала загрузки источников | `api/app/core/progress.py` | 7 |
+| Шкала загрузки и тайминги прогонов | `api/app/core/progress.py`, `schemas/admin.py` | 11 |
 
 ## Лицензия
 

docker-compose.prod.yml

@@ -152,6 +152,10 @@ services:
     depends_on:
       elasticsearch:
         condition: service_healthy
+      # CORE не отвечает на ключ с российских адресов — парсер ходит через
+      # sing-box (см. scripts/parsers/core.py)
+      singbox-proxy:
+        condition: service_started
 
   worker-notifier:
     build:

docs/ARCHITECTURE.md

@@ -46,7 +46,7 @@
           │ worker-    │   │ PostgreSQL 1.38 · Redis 1.35  │
           │ notifier   │   │ RabbitMQ .82 · MinIO 1.21     │
           │ SMTP email │   │ Elasticsearch (local 1.32)    │
-          └────────────┘   │ Ollama .109 (bge-m3, эмбед.)  │
+          └────────────┘   │ Ollama 1.40 (bge-m3, эмбед.)  │
                            │ OpenRouter/DeepSeek — LLM (опц.)│
                            │ [opt] Qdrant · Prometheus/Graf.│
                            └──────────────────────────────┘
@@ -78,10 +78,15 @@
 - **fingerprints** — `doc_id`, `hash_value` (BIGINT, Winnowing), `position` — для L1.
 - **usage_logs** — `user_id`, `action` — учёт лимитов по тарифу.
 - **parse_sources** — задания парсеров (админка): тип, query, годы, лимит, статус,
-  `last_run_id` — ссылка на последний прогон.
+  `last_run_id` — ссылка на последний прогон, `resume_token` — позиция
+  продолжения для массовых источников (номер статьи в дампе, токен страницы
+  бакета).
 - **parse_runs** — прогоны заливки: стадия, счётчики (`target/fetched/processed/
   added/duplicates/skipped/failed`), `cancel_requested`, `heartbeat_at`, журнал
-  событий (JSON). Из них админка рисует шкалу загрузки, см. §12.
+  событий (JSON). Тайминги раздельные: `started_at` — постановка в очередь,
+  `run_started_at` — реальный старт работы воркером (при массовом запуске между
+  ними часы ожидания), `finished_at` — конец. Из них админка рисует шкалу
+  загрузки, см. §12.
 - **staged_works** — пользовательские загрузки на модерацию перед добавлением в корпус.
 - **admin_sessions** — одноразовые коды входа в админку.
 
@@ -92,7 +97,7 @@
 | Очередь | Задачи | Воркер |
 |---------|--------|--------|
 | `queue.index` | `index.extract_and_check`, `index.add_document`, `index.run_parser`, `index.enrich_full_text`, `index.ingest_upload` | worker-indexer |
-| `queue.gpu` | `gpu.check_plagiarism`, `gpu.embed_documents`, `gpu.search_semantic` | worker-gpu |
+| `queue.gpu` | `gpu.check_plagiarism`, `gpu.embed_documents`, `gpu.search_semantic`, `gpu.index_stats` | worker-gpu |
 | `queue.gost` | `gost.format_bibliography` | worker-gost |
 | `queue.notify` | `notify.send_task_done`, `notify.send_verification` | worker-notifier |
 
@@ -116,10 +121,20 @@
 `app.bibliography.build_bibliography` (сортировка кириллица→латиница, нумерация,
 формат 7.1/7.0.5) → результат.
 
-**Наполнение корпуса.** админка/CLI → `index.run_parser` (OpenAlex/arXiv/PMC/
-КиберЛенинка, фильтр `is_oa`) → `index.add_document` (дедуп по `ext_id`,
-fingerprints, MinHash, эмбеддинг) → `index.enrich_full_text` (скачать OA-PDF →
-MinIO → переиндексация). Ход заливки пишется в `parse_runs` (§12).
+**Наполнение корпуса.** админка → `index.run_parser` — один конвейер для всех
+источников, со шкалой, журналом и кнопкой остановки. Внутри два пути записи:
+
+- *обычные источники* (OpenAlex/arXiv/PMC/КиберЛенинка, фильтр `is_oa`) —
+  `index.add_document` на каждый документ: дедуп по `ext_id`, fingerprints,
+  MinHash, Elasticsearch, эмбеддинг, затем `index.enrich_full_text` (скачать
+  OA-PDF → MinIO → переиндексация);
+- *массовые источники* (`wikipedia_ru`, `pmc_bulk`) — парсер отдаёт генератор,
+  запись идёт пачками через `COPY` (`app/bulk_writer.py`), позиция продолжения
+  хранится в `parse_sources.resume_token`. Эмбеддинги там не считаются: они
+  медленнее заливки на порядок и стали бы её узким местом, вектора
+  досчитываются отдельно (§12).
+
+Ход заливки в обоих случаях пишется в `parse_runs` (§12).
 Второй путь наполнения — ручная загрузка файлов админом: api сохраняет их в
 MinIO (`corpus-upload/`) → `index.ingest_upload` (извлечь текст → `add_document`,
 `source=manual_upload`). Это не проверка на плагиат: файл сразу становится
@@ -165,7 +180,8 @@ MinIO (`corpus-upload/`) → `index.ingest_upload` (извлечь текст
 | Redis 7 | 1.35 (выделенный LXC) | кэш, rate-limits, LSH |
 | RabbitMQ | 192.168.20.82 | брокер Celery |
 | MinIO (S3) | 1.21 | документы, full-text, бэкапы |
-| Ollama (bge-m3, эмбеддинги) | 192.168.20.109 «embedding-gpu» | RX580; известный failure mode — amdgpu ring timeout вешает Vulkan-контекст, лечится `systemctl restart ollama` |
+| Ollama (bge-m3, эмбеддинги) | 192.168.1.40 «embedding-cpu» (VM 210 на хосте pve2 .1.37) | Xeon 4314, AVX-512+VNNI, 8 vCPU; модель всегда в RAM (`OLLAMA_KEEP_ALIVE=-1`), сторожевой таймер раз в 2 мин перезапускает зависшую Ollama. Замер на данных корпуса: 3.6 док/с против 2.2 у прежнего сервера |
+| ~~Ollama на GPU~~ (выведен 31.08.2026) | 192.168.20.109 «embedding-gpu» | RX580; отказал по amdgpu ring timeout (Vulkan-контекст умирал при живом systemd-юните). Оставлен как есть — откат сводится к возврату `OLLAMA_URL` в Infisical |
 | OpenRouter (DeepSeek, L4 LLM) | облако | опционально вместо локальной Ollama (`LLM_BACKEND=openrouter`); из РФ доступен только через `singbox-proxy` |
 | Infisical (секреты) | 192.168.20.111 «VM111» | self-hosted, `infisical.jze9.ru`; единственный источник правды для `.env` на проде |
 | Qdrant / Prometheus / Grafana | 1.32 | опционально, под compose-профилями |
@@ -198,6 +214,24 @@ Identity (Universal Auth) и генерирует `.env` заново (`infisica
 
 ## 11. Качество и тесты
 
+**Замер качества детекции** — [`scripts/ops/detection_benchmark.py`](../scripts/ops/detection_benchmark.py).
+Делает из документов корпуса «студенческие работы» (дословная копия, лёгкий и
+сильный рерайт, плюс заведомо оригинальный текст) и прогоняет через настоящий
+путь L1. Первый замер, 05.09.2026:
+
+| Случай | Доля найденных |
+|--------|---------------:|
+| дословно | 100% |
+| лёгкий рерайт (выброшено каждое 10-е слово) | 100% |
+| сильный рерайт (каждое 3-е слово) | 0% — задача L3/L4, не L1 |
+| оригинальный текст | 0% ложных обвинений |
+
+Запускать после изменения порогов (`EXACT_FRAGMENT_THRESHOLD`), параметров
+winnowing и плотности отпечатков: без этих чисел непонятно, улучшение сделано
+или ухудшение. Ограничение замера: в выборку попадают только документы с
+реальной глубиной (>800 отпечатков) — по документам с одной аннотацией мерить
+нечего, и это само по себе показатель состояния корпуса.
+
 - **113 юнит-тестов** (pytest, per-service) на чистую логику L1-L4/скоринг/фрагменты/
   ГОСТ/библиография; инфра замокана или не нужна. Запуск: `make test`.
 - **Гейты CI**: ruff (весь Python) + mypy (доменная логика) + тесты — блокируют деплой.
@@ -207,8 +241,13 @@ Identity (Universal Auth) и генерирует `.env` заново (`infisica
 
 ## 12. Наблюдаемость и эксплуатация
 
-- **Мониторинг**: `antiplag_monitor.py` (cron 5 мин, 7 сервисов, email-алерт при смене
-  статуса). Опционально — Prometheus+Grafana (профиль `observability`, метрики API + Flower).
+- **Мониторинг**: [`scripts/ops/antiplag_monitor.py`](../scripts/ops/antiplag_monitor.py)
+  (cron 5 мин на 1.32, email при смене статуса). Адреса берутся из прод-`.env`, а не
+  зашиты в код: прежняя версия месяц проверяла остановленный CT 108 и не видела
+  реального сервера эмбеддингов — постоянный ложный DOWN заглушал настоящие аварии.
+  Проверяются в том числе **воркеры Celery**: живой брокер ещё не значит работающую
+  систему (05.09 воркеры час простаивали при «зелёном» брокере).
+  Опционально — Prometheus+Grafana (профиль `observability`, метрики API + Flower).
 - **Бэкапы**: `pg_dump→gzip→MinIO`, cron 03:00, ротация 14. Проверка восстановления —
   `scripts/ops/pg_restore_verify.sh`. HA/DR — [DR-HA.md](DR-HA.md).
 - **Шкала загрузки источников** (админка → «Источники»): каждый запуск создаёт строку
@@ -218,7 +257,10 @@ Identity (Universal Auth) и генерирует `.env` заново (`infisica
   Кнопки «Запустить всё» / «Остановить всё» — массовый старт и кооперативная отмена
   (флаг `cancel_requested`, воркер останавливается сам на ближайшем тике; уже
   начатый прогон не рвём посреди записи в базу).
-- **Панель отладки** (админка → «Отладка», `GET /api/admin/debug`): один срез —
+- **Панель отладки** (админка → «Отладка», `GET /api/admin/debug` + `/health`):
+  один срез — доступность инфраструктуры (PostgreSQL/Redis/MinIO/ES/Ollama/
+  брокер: этот блок показывается даже когда сам срез не собирается, потому что
+  при аварии первый вопрос — что именно отвалилось),
   живые воркеры Celery и что именно они крутят, глубина очередей RabbitMQ
   (в т.ч. `unacked` и число потребителей), покрытие корпуса эмбеддингами,
   активные и проблемные прогоны, зависшие прогоны (нет heartbeat >10 мин),
@@ -226,6 +268,18 @@ Identity (Universal Auth) и генерирует `.env` заново (`infisica
   `VECTOR_BACKEND`).
 - **Бюджет времени прогона** (`PARSER_TIME_BUDGET_S`, по умолчанию 1500с) —
   защита от краш-лупа по `consumer_timeout` RabbitMQ, см. [DR-HA.md](DR-HA.md) §6.
+- **Покрытие L3 меряется по индексу, а не по БД.** Колонка `documents.faiss_id`
+  для этого непригодна: отметка остаётся после пересоздания индекса (смена
+  модели/размерности) и после сбоев worker-gpu. Панель отладки спрашивает
+  реальное число векторов задачей `gpu.index_stats` и отдельно предупреждает о
+  ложных отметках; чинит их
+  [`scripts/ops/faiss_reconcile.py`](../scripts/ops/faiss_reconcile.py).
+- **Добор эмбеддингов** — [`scripts/ops/reembed_missing.py`](../scripts/ops/reembed_missing.py):
+  документ попадает в корпус сразу, а вектор для L3 считает отдельная задача
+  `gpu.embed_documents`; если worker-gpu или Ollama были недоступны, эти задачи
+  теряются и документ остаётся невидимым для семантического поиска. Скрипт
+  находит `faiss_id IS NULL` и переотправляет задачи пачками (dry-run по
+  умолчанию). Покрытие видно в панели отладки.
 
 ## 13. Безопасность
 

docs/DIAGRAM.md

@@ -31,7 +31,7 @@ flowchart TB
         PG[("PostgreSQL 1.38<br/>users/tasks/documents/<br/>fingerprints/...")]
         REDIS[("Redis 1.35<br/>кэш · rate-limit · LSH-индекс")]
         MINIO[("MinIO 1.21<br/>документы · full-text · бэкапы")]
-        OLLAMA["Ollama .109 embedding-gpu<br/>bge-m3, эмбеддинги (L3)"]
+        OLLAMA["Ollama 1.40 embedding-cpu<br/>bge-m3, эмбеддинги (L3)"]
         OPENROUTER["OpenRouter/DeepSeek<br/>LLM L4 (опц., через singbox-proxy)"]
         INFISICAL["Infisical .111<br/>секреты → .env на каждом деплое"]
     end

docs/DR-HA.md

@@ -55,6 +55,19 @@ Redis у нас — кэш/rate-limits/LSH-индекс (префикс `antipla
 | Векторный индекс | было | `VECTOR_BACKEND=qdrant` снимает (см. README) ✅ |
 | RabbitMQ .82 | да | мониторинг ловит падение ✅; кластер — по потребности |
 | app/ES 1.32 | да | воркеры горизонтальны; ES single-node (для BM25 не критично) |
+| Хост Proxmox .254 | **да, широкий** | эмбеддинги вынесены на pve2 ✅; брокер/прокси/секреты — нет, см. ниже |
+
+**Гипервизор — самая широкая единая точка отказа.** На хосте `192.168.20.254`
+одновременно живут RabbitMQ (.82), Infisical (.111) и CT 102 (.253) — фронтенд
+и реверс-прокси. С 31.08.2026 эмбеддинги отсюда вынесены: сервер `embedding-cpu`
+(192.168.1.40) стоит на другом физическом хосте (pve2, .1.37), так что падение
+.254 больше не уносит с собой L3. Его падение по-прежнему снимает сразу: приём
+и обработку задач (нет брокера), деплой (нет Infisical и Gitea) и весь публичный
+доступ (нет прокси) — при том что API, PostgreSQL, MinIO и сервер эмбеддингов
+продолжают работать. Проверено на практике 2026-08-28: хост перестал
+отвечать даже на ARP, всё перечисленное отвалилось разом, данные не пострадали.
+Разнести хотя бы прокси/брокер по разным физическим хостам — самая дешёвая
+мера; пока её нет, восстановление требует физического доступа к железу.
 
 ## 6. Известный операционный риск — RabbitMQ `consumer_timeout` vs долгие таски
 
@@ -66,7 +79,8 @@ Redis у нас — кэш/rate-limits/LSH-индекс (префикс `antipla
 (`restart: unless-stopped`) поднимает его заново, недоставленное сообщение
 передоставляется — и цикл повторяется бесконечно, монополизируя весь пул воркера
 (было и на `worker-indexer` из-за backoff `scripts/parsers/openalex.py`, и на
-`worker-gpu` из-за зависшей Ollama на embedding-gpu).
+`worker-gpu` из-за зависшей Ollama на прежнем embedding-gpu; на новом сервере
+эмбеддингов зависание закрыто сторожевым таймером на самой машине).
 
 Митигации (2026-08-27, сделано для `worker-indexer`):
 

docs/INGESTION.md

@@ -1,13 +1,18 @@
 # Наполнение корпуса — runbook
 
-## Текущее состояние (на 2026-08-27)
+## Текущее состояние (на 2026-08-31)
 
-- **165 480 документов**, русский теперь большинство: `ru` 97 507, `en` 67 646,
+- **177 247 документов**, русский большинство: `ru` 99 884, `en` 77 036,
   остальные языки — единицы/десятки. Проблема «не с чем сравнивать русские
   работы» из более ранней версии этого документа закрыта.
-- По источникам: CyberLeninka 97 506, OpenAlex 49 218, PMC 10 451, arXiv 8 304,
+- По источникам: CyberLeninka 99 883, OpenAlex 49 276, PMC 15 010, arXiv 13 077,
   `user_submission` (проверенные пользователями работы, не источник для сравнения
   сами с собой — см. ARCHITECTURE.md §7) 1.
+- Повторный прогон по уже залитым источникам даёт почти одни дубли (типично
+  1490 из 1500 на источник): прирост дают только новые публикации. Реальный
+  рост корпуса — поднятый `limit` или новые темы, а не повторный запуск.
+- OpenAlex при массовом запуске упирается в лимит вежливого пула (10 req/s
+  на mailto, общий для всех воркеров) — пауза между страницами поднята до 1с.
 - Добавлен 4-й парсер — **PMC** (PubMed Central, `scripts/parsers/pmc.py`),
   англоязычные научные статьи открытого доступа.
 - Массовое расширение по дисциплинам теперь двумя сидерами: `seed_ru_sources.py`
@@ -18,6 +23,85 @@
   закрыт бюджетом времени прогона и `worker_prefetch_multiplier=1` — подробности
   и почему префетч тут главный, см. [DR-HA.md](DR-HA.md) §6.
 
+### Глубина индексации — чем реально располагает детекция (замер 2026-08-28)
+
+Мерить глубину по `minio_key` (сохранён ли текст в MinIO) **нельзя**: PMC,
+например, кладёт тело статьи в отпечатки прямо при заливке, не сохраняя файл.
+Честный показатель — **число отпечатков на документ**: аннотация даёт десятки,
+полный текст — тысячи.
+
+| Источник | Документов | Глубоко (≥500 отпечатков) | Среднее отпечатков |
+|----------|-----------:|--------------------------:|-------------------:|
+| КиберЛенинка | 99 883 | 0 (0.0%) | **30** |
+| OpenAlex | 49 276 | 6 240 (12.7%) | 907 |
+| PMC | 14 910 | 14 519 (97.4%) | 2 208 |
+| arXiv | 13 077 | 12 236 (93.6%) | 4 035 |
+
+**Главная слабость — русская часть корпуса.** 56% базы (КиберЛенинка) в индексе
+представлено заголовком и аннотацией: списывание из тела русской статьи L1 не
+найдёт, хотя сервис рассчитан именно на русских студентов. Причина не в
+алгоритме: search API отдаёт только аннотацию и OCR-фрагмент (~700 символов), а
+`url` ведёт на HTML-страницу — докачка по нему бесполезна (замер: 0 из 8).
+Частично лечится `scripts/ops/backfill_cyberleninka_pdf.py`: PDF доступен прямым
+адресом `{url}/pdf` (проверено: 44 из 50, в среднем 23 тыс. символов, глубина
+30 → ~1450 отпечатков).
+
+**Но массовый прогон упирается в защиту сайта.** Замер 2026-08-28: первые ~130
+статей скачались штатно, дальше КиберЛенинка перестала отдавать PDF и начала
+возвращать HTML-заглушку ~5.7 КБ — счётчик успехов замер на 122, скрипт работал
+вхолостую. Расчёт «48 часов на 100 тысяч при 1 req/s» этим опровергнут. Чтобы
+углубить русскую часть корпуса, нужен другой подход: заметно большие паузы,
+разные исходящие адреса или договорённость с источником.
+
+Покрытие L3: 60 993 документа числились векторизованными ошибочно — отметки
+сброшены `faiss_reconcile.py`, после чего 31.08 запущен пересчёт всех 84 094
+документов без вектора. Считает новый сервер эмбеддингов (192.168.1.40,
+3.6 док/с против 2.2 у прежнего), полный проход занимает около 6.5 часов.
+
+### Источники русского текста — что проверено (31.08.2026)
+
+| Источник | Объём | Годен для массовой заливки |
+|----------|-------|----------------------------|
+| **Википедия ru** | дамп 5.6 ГБ, ~2 млн статей | **да** — тип источника `wikipedia_ru`, ~919 отпечатков на статью. Дамп качается заранее (Wikimedia отдаёт 403 без осмысленного User-Agent и рвёт долгие потоковые соединения) |
+| КиберЛенинка | ~3 млн статей | нет — блокирует выкачку PDF после ~130 запросов |
+| OpenAlex `language:ru` + OA | заявлено 395 410 | практически нет — по прямым `pdf_url` скачалось 2 из 10 (остальное 403 издателей), а метка языка ненадёжна: в выдаче попадаются англоязычные журналы |
+| eLIBRARY.RU (РИНЦ) | ~40 млн | только по договору, публичной выгрузки нет |
+| Math-Net.Ru | российские матжурналы | архив отдаёт 403 |
+| НЭБ, BASE, вузовские DSpace | — | открыты, механизм выгрузки не проверялся |
+
+Википедия формально не научный источник, но студенты копируют из неё чаще всего,
+а по объёму связного русского текста ей нет альтернативы среди доступного.
+
+### Массовые источники — тот же конвейер, что и обычные
+
+Постраничные API дают 1-2 статьи в секунду и упираются в rate limit — миллионы
+так не залить. Для объёма есть два типа источника, которые читают дамп или
+бакет потоком:
+
+| Тип | Откуда | Особенность |
+|-----|--------|-------------|
+| `wikipedia_ru` | локальный дамп `scripts/parsers/ruwiki.xml.bz2` | позиция продолжения — номер статьи в дампе |
+| `pmc_bulk` | бакет `pmc-oa-opendata` (открыт, ключ не нужен) | позиция — токен страницы бакета; у каждой статьи готовый извлечённый текст |
+
+Заводятся и запускаются они как любой другой источник — через админку, и точно
+так же показывают шкалу, журнал и кнопку остановки. Отличия внутри:
+
+- парсер отдаёт **генератор**, а не список: миллионы статей в память не влезут;
+- запись идёт пачками через `COPY` (`worker-indexer/app/bulk_writer.py`) —
+  построчная вставка даёт 6.7 тыс. строк/с против 21 тыс. у COPY, а миллион
+  статей это ~2 млрд отпечатков;
+- **эмбеддинги при заливке не считаются**: они медленнее заливки и сделали бы её
+  узким местом. L1 и L2 работают сразу, векторы досчитываются потом
+  (`scripts/ops/reembed_missing.py`);
+- позиция продолжения хранится в `parse_sources.resume_token`, поэтому источник
+  запускается повторно до исчерпания — каждый прогон берёт следующую порцию и
+  укладывается в бюджет времени таска.
+
+Планировать объём: 1 млн статей ≈ 2 млрд отпечатков ≈ 200 ГБ в базе с индексами.
+При таком росте индексы перестают помещаться в память сервера БД — проверено на
+практике: поиск L1 деградировал с 31 мс до 484 мс, пока не увеличили RAM и
+`shared_buffers` (см. DR-HA.md).
+
 ## Что подготовлено
 
 - **Парсер CyberLeninka починен** (`scripts/parsers/cyberleninka.py`): раньше слал GET
@@ -61,6 +145,18 @@ python scripts/seed_ru_sources.py --apply --limit 500
 - **Страница «Отладка»** — очереди, воркеры, покрытие эмбеддингами, зависшие и
   упавшие прогоны (см. ARCHITECTURE.md §12).
 
+После большой заливки — свериться с покрытием L3 (панель отладки, «Векторов в
+индексе»). Порядок именно такой, из двух шагов:
+
+1. `scripts/ops/faiss_reconcile.py` (в контейнере worker-gpu) — сверяет отметки
+   `faiss_id` с реальным содержимым индекса и обнуляет ложные. Без этого шага
+   документы, потерявшие вектор при пересоздании индекса, не попадут на
+   пересчёт: они всё ещё «отмечены».
+2. `scripts/ops/reembed_missing.py` (в контейнере worker-indexer) — отправляет
+   `gpu.embed_documents` для всех `faiss_id IS NULL`.
+
+Оба по умолчанию dry-run, отправляют/меняют только с `--apply`.
+
 Прогон со статусом `partial` — это не ошибка: сработал бюджет времени
 (`PARSER_TIME_BUDGET_S`, 1500с), заливка остановилась раньше `consumer_timeout`
 RabbitMQ. Остаток добирается повторным запуском источника.
@@ -80,8 +176,11 @@ SELECT source, count(*) FROM documents WHERE source='cyberleninka';   -- > 0
 
 - Больше тем + выше `--limit`; добавить OpenAlex `lang=ru` (качество ниже — англ.
   заголовки с меткой ru).
-- Для миллионов — **bulk** (снапшот OpenAlex на S3), а не постраничный API.
+- Для миллионов — **bulk**, а не постраничный API. Снапшот OpenAlex для этого не
+  годится: там только метаданные, а миллионы аннотаций детекции не дают (см.
+  провал КиберЛенинки выше). Рабочий источник полных текстов — бакет
+  `pmc-oa-opendata`, см. «Массовая заливка» выше.
 - На масштабе обязателен `VECTOR_BACKEND=qdrant` (FAISS flat не тянет), а таблица
-  `fingerprints` (уже ~88M строк на 165K доков — партиционирование стоит планировать
+  `fingerprints` (уже ~113M строк на 177K доков — партиционирование стоит планировать
   заранее, не постфактум) потребует партиционирования. См.
   [ARCHITECTURE.md](ARCHITECTURE.md) и [DR-HA.md](DR-HA.md).

scripts/deploy.sh

@@ -43,6 +43,7 @@ fi
 
 REBUILD=""
 FRONTEND_CHANGED=0
+PARSERS_CHANGED=0
 if [ "$FULL" = 1 ]; then
   REBUILD="$ALL_BACKEND"
   FRONTEND_CHANGED=1
@@ -51,6 +52,12 @@ else
     echo "$CHANGED" | grep -qE "^services/$svc/" && REBUILD="$REBUILD $svc"
   done
   echo "$CHANGED" | grep -qE '^services/frontend/' && FRONTEND_CHANGED=1
+  # Парсеры не вшиты в образ, а смонтированы в worker-indexer (см. compose),
+  # поэтому пересобирать нечего. Но процесс воркера держит модуль парсера в
+  # памяти с прошлого прогона: без перезапуска правка молча не применяется —
+  # заливка продолжает ходить по старому коду, и это не видно ниоткуда, кроме
+  # тела запросов в логах. Ловилось на CORE 16.09.2026.
+  echo "$CHANGED" | grep -qE '^scripts/parsers/' && PARSERS_CHANGED=1
 fi
 REBUILD="$(echo "$REBUILD" | xargs || true)"
 
@@ -111,6 +118,13 @@ echo "==> [4/6] Применение секретов к неизменивши
 # shellcheck disable=SC2086
 $COMPOSE up -d $ALL_BACKEND
 
+# Правка парсера доезжает монтированием, но модуль уже загружен в память
+# воркера — перезапускаем, если образ и так не пересобирался выше.
+if [ "$PARSERS_CHANGED" = 1 ] && ! echo " $REBUILD " | grep -q " worker-indexer "; then
+  echo "==> [4.5/6] Парсеры менялись — перезапуск worker-indexer"
+  $COMPOSE restart worker-indexer
+fi
+
 echo "==> [5/6] Миграции БД (с ретраем)"
 for i in $(seq 1 10); do
   $COMPOSE exec -T api alembic upgrade head && break

scripts/ops/antiplag_monitor.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Health-монитор anti-plagiarism: письмо при СМЕНЕ статуса сервиса, без спама.
+
+Запускается по cron на app-хосте (1.32) каждые 5 минут:
+    */5 * * * * /usr/bin/python3 /home/user/antiplag_monitor.py >> ~/.antiplag-monitor/run.log 2>&1
+
+Живёт в репозитории намеренно: прошлая версия лежала только на сервере, ничем
+не версионировалась и месяц проверяла топологию, которой уже нет — вечный
+ложный DOWN на остановленном CT 108 и полная слепота к реальному серверу
+эмбеддингов. Постоянный ложный сигнал хуже отсутствия сигнала: на его фоне
+теряется настоящая авария.
+
+Что проверяется и почему именно это:
+- API, PostgreSQL, Redis, RabbitMQ, MinIO, Elasticsearch — без них сервис не
+  принимает и не обрабатывает работы;
+- Ollama на 1.40 — эмбеддинги для L3 (адрес брать из .env, а не хардкодить:
+  он уже дважды переезжал);
+- воркеры Celery — самое важное дополнение: 05.09 брокер лежал час, воркеры
+  молчали, а прежний монитор рапортовал, что всё хорошо, потому что смотрел
+  только на TCP-порты.
+
+OpenRouter (L4) намеренно не проверяется: это внешний сервис за VPN-прокси, его
+недоступность не ломает основную проверку — L4 лишь уточняет вердикт.
+"""
+
+import json
+import os
+import smtplib
+import socket
+import ssl
+import subprocess
+import urllib.request
+from datetime import datetime
+from email.mime.text import MIMEText
+
+APP_DIR = os.environ.get("APP_DIR", "/home/user/anti-plagiarism")
+STATE_FILE = os.path.expanduser("~/.antiplag-monitor/state.json")
+
+SMTP_HOST, SMTP_PORT = "mail.jze9mail.ru", 587
+SMTP_USER = os.environ.get("MONITOR_SMTP_USER", "noreply")
+SMTP_PASS = os.environ.get("MONITOR_SMTP_PASS", "kGy3vgt6EuiUBMNDmV01Ng")
+SMTP_FROM = "noreply@jze9mail.ru"
+ALERT_TO = os.environ.get("MONITOR_ALERT_TO", "jze9programer@gmail.com")
+
+
+def env_value(key: str, default: str = "") -> str:
+    """Значение из прод-.env (он генерируется из Infisical на каждом деплое).
+
+    Адреса инфраструктуры читаем оттуда, а не хардкодим: сервер эмбеддингов уже
+    переезжал дважды, и монитор каждый раз оставался со старым адресом.
+    """
+    path = os.path.join(APP_DIR, ".env")
+    try:
+        with open(path, encoding="utf-8") as fh:
+            for line in fh:
+                line = line.strip()
+                if line.startswith(f"{key}="):
+                    return line.split("=", 1)[1].strip().strip("'\"")
+    except Exception:
+        pass
+    return default
+
+
+def host_port_from_url(url: str, default_port: int) -> tuple[str, int]:
+    """Разобрать URL в пару (host, port), отбросив логин с паролем.
+
+    В REDIS_URL и RABBITMQ_URL креды идут перед адресом
+    (`redis://:пароль@host:port/0`), и без их отсечения разбор падает.
+    """
+    rest = url.split("//", 1)[-1].split("/", 1)[0]
+    rest = rest.rpartition("@")[2] or rest
+    if ":" in rest:
+        host, _, port = rest.partition(":")
+        return host, int(port or default_port)
+    return rest, default_port
+
+
+def check_tcp(host: str, port: int) -> bool:
+    try:
+        with socket.create_connection((host, port), timeout=5):
+            return True
+    except Exception:
+        return False
+
+
+def check_http(url: str) -> bool:
+    try:
+        with urllib.request.urlopen(url, timeout=8) as r:
+            return r.status == 200
+    except Exception:
+        return False
+
+
+def check_in_api_container(command: str) -> bool:
+    """Проверка изнутри контейнера — так же, как это видит приложение."""
+    try:
+        out = subprocess.run(
+            ["docker", "exec", "antiplagiator-api", "sh", "-c", command],
+            capture_output=True, text=True, timeout=20,
+        )
+        return out.stdout.strip() == "200"
+    except Exception:
+        return False
+
+
+def check_celery_workers() -> bool:
+    """Отвечают ли воркеры на ping.
+
+    Живой брокер ещё не значит работающую систему: воркер может не суметь к
+    нему подключиться и молча простаивать — именно так и было 05.09.
+    """
+    try:
+        out = subprocess.run(
+            ["docker", "exec", "antiplagiator-api", "python", "-c",
+             "from app.core.celery_app import celery_app;"
+             "print(len(celery_app.control.inspect(timeout=5).ping() or {}))"],
+            capture_output=True, text=True, timeout=30,
+        )
+        return int(out.stdout.strip() or 0) >= 4      # api ждёт 4 воркера
+    except Exception:
+        return False
+
+
+def build_checks() -> list[tuple[str, callable]]:
+    """Список проверок; адреса — из прод-.env, чтобы не разъезжаться с реальностью."""
+    pg_host = env_value("POSTGRES_HOST", "192.168.1.38")
+    redis_host, redis_port = host_port_from_url(
+        env_value("REDIS_URL", "redis://192.168.1.35:6379/0"), 6379)
+    minio_host, minio_port = host_port_from_url(
+        "http://" + env_value("MINIO_ENDPOINT", "192.168.1.21:9000"), 9000)
+    ollama_url = env_value("OLLAMA_URL", "http://192.168.1.40:11434")
+
+    rabbit_host, rabbit_port = host_port_from_url(
+        env_value("RABBITMQ_URL", "amqp://guest:guest@192.168.20.82:5672/"), 5672)
+
+    return [
+        ("API", lambda: check_http("http://localhost:8000/health")),
+        ("PostgreSQL", lambda: check_tcp(pg_host, 5432)),
+        ("Redis", lambda: check_tcp(redis_host, redis_port)),
+        ("RabbitMQ", lambda: check_tcp(rabbit_host, rabbit_port)),
+        ("MinIO", lambda: check_tcp(minio_host, minio_port)),
+        ("Elasticsearch", lambda: check_in_api_container(
+            "curl -s -o /dev/null -w '%{http_code}' http://elasticsearch:9200")),
+        ("Embeddings", lambda: check_http(f"{ollama_url}/api/version")),
+        ("CeleryWorkers", check_celery_workers),
+    ]
+
+
+def send_alert(subject: str, body: str) -> None:
+    msg = MIMEText(body, "plain", "utf-8")
+    msg["Subject"] = subject
+    msg["From"] = SMTP_FROM
+    msg["To"] = ALERT_TO
+    ctx = ssl.create_default_context()
+    with smtplib.SMTP(SMTP_HOST, SMTP_PORT, timeout=25) as s:
+        s.ehlo()
+        s.starttls(context=ctx)
+        s.ehlo()
+        s.login(SMTP_USER, SMTP_PASS)
+        s.send_message(msg)
+
+
+def main() -> None:
+    results = {name: fn() for name, fn in build_checks()}
+
+    prev: dict = {}
+    if os.path.exists(STATE_FILE):
+        try:
+            with open(STATE_FILE) as fh:
+                prev = json.load(fh)
+        except Exception:
+            prev = {}
+
+    changes = []
+    for name, ok in results.items():
+        was = prev.get(name, True)          # первый запуск считаем нормой
+        if was and not ok:
+            changes.append(f"УПАЛ: {name}")
+        elif not was and ok:
+            changes.append(f"восстановился: {name}")
+
+    if changes:
+        ts = datetime.now().strftime("%Y-%m-%d %H:%M")
+        status = "\n".join(f"  {'OK  ' if v else 'DOWN'}  {k}" for k, v in results.items())
+        body = (f"Изменения статуса сервисов anti-plagiarism ({ts}):\n\n"
+                + "\n".join(changes) + "\n\nТекущий статус:\n" + status)
+        subject = f"[anti-plagiarism] {changes[0]}"
+        if len(changes) > 1:
+            subject += f" (+{len(changes) - 1})"
+        try:
+            send_alert(subject, body)
+        except Exception as e:
+            print(f"не удалось отправить алерт: {e}")
+
+    os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
+    with open(STATE_FILE, "w") as fh:
+        json.dump(results, fh)
+
+    line = " ".join(f"{k}={'OK' if v else 'DOWN'}" for k, v in results.items())
+    print(datetime.now().strftime("%H:%M"), "|", line)
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/backfill_cyberleninka_pdf.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Углубить индексацию КиберЛенинки: скачать PDF статей и переиндексировать по ним.
+
+Самая большая слабость корпуса (замер 2026-08-28): 99 883 документа
+КиберЛенинки — 56% всей базы — имеют в среднем 30 отпечатков. Это заголовок с
+аннотацией, тела статьи в индексе нет. Списывание из русской статьи система
+не найдёт, хотя сервис рассчитан именно на русских студентов.
+
+Причина: search API отдаёт только аннотацию и короткий OCR-фрагмент (~700
+символов), а `url` ведёт на HTML-страницу — докачка по нему бесполезна
+(замер: 0 из 8). Зато PDF доступен прямым адресом `{url}/pdf` и извлекается:
+проверка на 4 статьях дала 13-40 тыс. символов у трёх, у одной 0 (скан без
+текстового слоя — такие пропускаем).
+
+Дальше — общий путь `store_full_text`: MinIO + пересчёт отпечатков L1 по
+полному тексту + обновление MinHash LSH (L2).
+
+Масштаб полного прогона: ~28 часов при вежливом 1 req/s, порядка +300 млн строк
+в fingerprints (~30 ГБ). Запускать в фоне (nohup) и следить за местом на БД.
+
+Запуск (в контейнере worker-indexer):
+    cd /home/user/anti-plagiarism
+    C="docker compose -f docker-compose.prod.yml exec -T worker-indexer python -"
+    $C < scripts/ops/backfill_cyberleninka_pdf.py                    # dry-run
+    $C --apply --limit 50 < scripts/ops/backfill_cyberleninka_pdf.py # пробная порция
+    $C --apply < scripts/ops/backfill_cyberleninka_pdf.py            # всё (сутки)
+
+Идемпотентно: документы с уже проставленным minio_key пропускаются, так что
+прерванный прогон продолжается с того же места.
+"""
+
+import argparse
+import time
+
+RATE_LIMIT_DELAY = 1.0     # КиберЛенинка не любит частых запросов
+MIN_USEFUL_CHARS = 1500    # меньше — скан без текстового слоя либо обрывок
+MAX_PDF_BYTES = 30 * 1024 * 1024
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--apply", action="store_true", help="реально качать и сохранять")
+    ap.add_argument("--limit", type=int, default=0, help="взять не больше N документов (0 = все)")
+    args = ap.parse_args()
+
+    import httpx
+    from app.db import db_session
+    from app.extractors.pdf import extract_text_from_pdf
+    from app.tasks.index import store_full_text
+    from sqlalchemy import text
+
+    with db_session() as s:
+        sql = """
+            SELECT id, url FROM documents
+            WHERE source = 'cyberleninka' AND minio_key IS NULL AND url IS NOT NULL
+            ORDER BY id
+        """
+        if args.limit:
+            sql += f" LIMIT {int(args.limit)}"
+        rows = s.execute(text(sql)).all()
+
+    print(f"документов КиберЛенинки без полного текста: {len(rows)}")
+    if not rows:
+        return
+    if not args.apply:
+        print(f"[dry-run] пример: {rows[0][1]}/pdf")
+        print(f"оценка полного прогона: ~{len(rows) * RATE_LIMIT_DELAY / 3600:.1f} ч, "
+              f"~{len(rows) * 3000 / 1e6:.0f} млн строк отпечатков")
+        print("Запустите с --apply (сначала --limit 50).")
+        return
+
+    client = httpx.Client(
+        timeout=30, follow_redirects=True,
+        headers={"User-Agent": "Mozilla/5.0 (compatible; AcademicHelper/1.0; +noreply@jze9.ru)"},
+    )
+    done = no_text = failed = 0
+    chars_total = 0
+    t0 = time.time()
+
+    for n, (doc_id, url) in enumerate(rows, 1):
+        try:
+            resp = client.get(url.rstrip("/") + "/pdf")
+            if resp.status_code != 200 or "pdf" not in resp.headers.get("content-type", "").lower() or len(resp.content) > MAX_PDF_BYTES:
+                no_text += 1
+            else:
+                body = extract_text_from_pdf(resp.content)
+                if len(body) < MIN_USEFUL_CHARS:
+                    no_text += 1          # скан без текстового слоя
+                else:
+                    store_full_text(doc_id, body)
+                    done += 1
+                    chars_total += len(body)
+        except Exception as e:
+            failed += 1
+            if failed <= 5:
+                print(f"  doc {doc_id}: {type(e).__name__}: {str(e)[:80]}")
+
+        if n % 25 == 0:
+            el = time.time() - t0
+            print(f"  {n}/{len(rows)} · углублено {done} · без текста {no_text} · "
+                  f"ошибок {failed} · {n / el:.2f} док/с · осталось ~{(len(rows) - n) / max(n / el, 0.01) / 3600:.1f} ч",
+                  flush=True)
+        time.sleep(RATE_LIMIT_DELAY)
+
+    avg = chars_total // done if done else 0
+    print(f"\nГотово за {(time.time() - t0) / 60:.1f} мин: углублено {done}, "
+          f"без текстового слоя {no_text}, ошибок {failed}, средний объём {avg} симв.")
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/backfill_pmc_fulltext.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Бэкфилл полного текста для уже залитых документов PMC.
+
+Зачем: PMC отдаёт тело статьи прямо в ответе efetch (40-50 тыс. символов), но
+документы, залитые до включения сохранения full_text, остались в базе с одной
+аннотацией — L1 сравнивает по ней и не видит тело статьи. Докачка PDF по url
+здесь не работает: ссылка ведёт на HTML-страницу NCBI (замер: 0 из 8). Поэтому
+текст берём тем же путём, что и парсер, — через API.
+
+Замер на проде 2026-08-28: 12 368 документов PMC без полного текста.
+
+Что делает для каждого документа: efetch по PMC id → извлечение текста →
+`store_full_text` (та же функция, что у задачи докачки: MinIO + пересчёт
+fingerprints по полному тексту + обновление MinHash LSH).
+
+Идемпотентно: документы с уже проставленным minio_key не берутся.
+
+Запуск (в контейнере worker-indexer, репозиторий внутрь не смонтирован):
+    cd /home/user/anti-plagiarism
+    C="docker compose -f docker-compose.prod.yml exec -T worker-indexer python -"
+    $C < scripts/ops/backfill_pmc_fulltext.py                  # dry-run
+    $C --apply --limit 40 < scripts/ops/backfill_pmc_fulltext.py   # пробная порция
+    $C --apply < scripts/ops/backfill_pmc_fulltext.py              # всё
+
+Внимание: каждый документ добавляет ~3.5 тыс. строк в fingerprints (~4.5 ГБ
+на все 12 тыс.). Перед полным прогоном стоит убедиться в свободном месте на
+сервере БД.
+"""
+
+import argparse
+import sys
+import time
+
+BATCH = 20  # столько id за один efetch — как в самом парсере
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--apply", action="store_true", help="реально сохранять (иначе dry-run)")
+    ap.add_argument("--limit", type=int, default=0, help="взять не больше N документов (0 = все)")
+    args = ap.parse_args()
+
+    if "/parsers" not in sys.path:
+        sys.path.insert(0, "/parsers")
+
+    from app.db import db_session
+    from app.tasks.index import store_full_text
+    from sqlalchemy import text
+
+    with db_session() as s:
+        sql = """
+            SELECT id, ext_id FROM documents
+            WHERE source = 'pmc' AND minio_key IS NULL AND ext_id IS NOT NULL
+            ORDER BY id
+        """
+        if args.limit:
+            sql += f" LIMIT {int(args.limit)}"
+        rows = s.execute(text(sql)).all()
+
+    # ext_id формата "pmc:13521573" → числовой id для efetch
+    todo = {ext.split(":", 1)[-1]: doc_id for doc_id, ext in rows if ":" in ext}
+    print(f"документов PMC без полного текста: {len(rows)} (пригодных ext_id: {len(todo)})")
+    if not todo:
+        return
+
+    if not args.apply:
+        print(f"[dry-run] первые id: {list(todo.items())[:5]}")
+        print("Запустите с --apply (рекомендуется сначала --limit 40).")
+        return
+
+    from pmc import PMCParser
+
+    parser = PMCParser()
+    ids = list(todo)
+    done = failed = empty = 0
+    chars_total = 0
+    t0 = time.time()
+
+    for i in range(0, len(ids), BATCH):
+        batch = ids[i : i + BATCH]
+        try:
+            resp = parser.client.get(
+                "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi",
+                params=parser._params(db="pmc", id=",".join(batch), rettype="full", retmode="xml"),
+            )
+            resp.raise_for_status()
+            articles = parser._parse_articles(resp.text)
+        except Exception as e:
+            failed += len(batch)
+            print(f"  батч {i // BATCH}: ошибка запроса: {e}")
+            continue
+
+        for raw in articles:
+            doc = parser.transform(raw)
+            ext = (doc.get("ext_id") or "").split(":", 1)[-1]
+            doc_id = todo.get(ext)
+            full = doc.get("full_text") or ""
+            if not doc_id:
+                continue
+            if len(full) < 1000:  # аннотация вместо тела — сохранять нечего
+                empty += 1
+                continue
+            try:
+                store_full_text(doc_id, full)
+                done += 1
+                chars_total += len(full)
+            except Exception as e:
+                failed += 1
+                print(f"  doc {doc_id}: не сохранён: {e}")
+
+        if (i // BATCH) % 10 == 0:
+            speed = done / max(time.time() - t0, 1)
+            print(f"  обработано {i + len(batch)}/{len(ids)} · сохранено {done} · "
+                  f"{speed:.1f} док/с")
+        time.sleep(0.35)  # лимит NCBI без ключа — 3 запроса/с
+
+    avg = chars_total // done if done else 0
+    print(f"\nГотово за {time.time() - t0:.0f}с: сохранено {done}, "
+          f"без тела статьи {empty}, ошибок {failed}, средний объём {avg} симв.")
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/detection_benchmark.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""Замер качества детекции на реальном корпусе: что находим и что выдумываем.
+
+Зачем: до сих пор о качестве проверки мы знали только «механизм жив» — находит
+подброшенный фрагмент. Этого мало. Продукт продаёт процент заимствований, и
+нужно знать две вещи: сколько списываний система пропускает (полнота) и как
+часто обвиняет невиновных (точность). Без этих чисел непонятно, что улучшать —
+пороги, глубину корпуса или алгоритм.
+
+Как устроен замер. Берём документы из самого корпуса и делаем из них
+«студенческие работы» четырёх видов:
+
+  дословно      — фрагмент скопирован как есть (обязан находиться);
+  лёгкий рерайт — выброшено каждое 10-е слово (обязан находиться);
+  сильный рерайт— выброшено каждое 3-е слово (L1 не обязан; это работа L3/L4);
+  оригинал      — текст, которого в корпусе нет (обязан НЕ находиться).
+
+Считается путь L1 — тот же, что в index.extract_and_check: фрагментация,
+winnowing по каждому фрагменту, поиск по отпечаткам с порогом
+EXACT_FRAGMENT_THRESHOLD. Уровни L3/L4 сюда не входят намеренно: они требуют
+GPU-воркера и на порядок медленнее, а мерить нужно в первую очередь основу.
+
+Запуск (в контейнере worker-indexer):
+    cd /home/user/anti-plagiarism
+    docker compose -f docker-compose.prod.yml exec -T worker-indexer python - \\
+        < scripts/ops/detection_benchmark.py
+    ... python - --docs 40 < scripts/ops/detection_benchmark.py
+
+Ничего не пишет в базу — только читает.
+"""
+
+import argparse
+import random
+
+
+def make_cases(text: str, words_taken: int) -> dict[str, str]:
+    """Сделать из текста источника четыре «студенческие работы»."""
+    words = text.split()
+    start = len(words) // 3
+    chunk = words[start : start + words_taken]
+
+    return {
+        "дословно": " ".join(chunk),
+        "лёгкий рерайт": " ".join(w for i, w in enumerate(chunk) if i % 10),
+        "сильный рерайт": " ".join(w for i, w in enumerate(chunk) if i % 3),
+    }
+
+
+def original_text(rnd: random.Random, words_taken: int) -> str:
+    """Текст, которого заведомо нет в корпусе — проверка на ложные обвинения."""
+    topics = [
+        "вчера вечером я варил гречку с грибами и вспоминал поездку на озеро",
+        "мой сосед купил подержанный велосипед и красит его в оранжевый цвет",
+        "бабушка печёт пироги с капустой по субботам и зовёт всех соседей",
+        "кот запрыгнул на подоконник и уронил горшок с геранью на пол",
+        "в субботу мы чинили забор и обсуждали цены на доски и гвозди",
+    ]
+    out: list[str] = []
+    while len(out) < words_taken:
+        out.extend(rnd.choice(topics).split())
+    return " ".join(out[:words_taken])
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--docs", type=int, default=25, help="сколько документов взять для замера")
+    ap.add_argument("--words", type=int, default=400, help="сколько слов «списывать»")
+    ap.add_argument("--seed", type=int, default=20260905, help="зерно случайности (для повторяемости)")
+    args = ap.parse_args()
+
+    from app.algorithms.winnowing import winnow
+    from app.config import settings
+    from app.db import db_session, get_minio
+    from app.fragments import split_into_fragments
+    from app.models import Document, Fingerprint
+    from sqlalchemy import func, select
+    from sqlalchemy import text as sql_text
+
+    rnd = random.Random(args.seed)
+
+    # Берём документы с реальной глубиной: по аннотации в 30 отпечатков мерить
+    # нечего, и такой замер сказал бы больше о корпусе, чем об алгоритме
+    with db_session() as s:
+        rows = s.execute(sql_text("""
+            SELECT d.id, d.source, d.minio_key, d.abstract
+            FROM documents d
+            JOIN (SELECT doc_id, count(*) c FROM fingerprints
+                  GROUP BY doc_id HAVING count(*) > 800) f ON f.doc_id = d.id
+            WHERE d.source <> 'user_submission'
+            ORDER BY random() LIMIT :n
+        """), {"n": args.docs}).all()
+
+    print(f"документов в замере: {len(rows)}, «списываем» по {args.words} слов")
+    print(f"порог срабатывания фрагмента: {settings.EXACT_FRAGMENT_THRESHOLD}%\n")
+
+    def find_source(work_text: str) -> set[int]:
+        """Прогнать «работу» через L1 и вернуть найденные документы-источники."""
+        found: set[int] = set()
+        frags = split_into_fragments(
+            work_text,
+            window=settings.FRAGMENT_WINDOW_WORDS,
+            overlap=settings.FRAGMENT_OVERLAP_WORDS,
+        )
+        with db_session() as s:
+            for frag in frags:
+                fp = winnow(frag["text"])
+                if not fp:
+                    continue
+                hit = s.execute(
+                    select(Fingerprint.doc_id, func.count(Fingerprint.id).label("c"))
+                    .join(Document, Document.id == Fingerprint.doc_id)
+                    .where(
+                        Fingerprint.hash_value.in_(list(fp)),
+                        Document.source != "user_submission",
+                    )
+                    .group_by(Fingerprint.doc_id)
+                    .order_by(func.count(Fingerprint.id).desc())
+                    .limit(1)
+                ).first()
+                if hit and hit[1] / len(fp) * 100 >= settings.EXACT_FRAGMENT_THRESHOLD:
+                    found.add(hit[0])
+        return found
+
+    stats: dict[str, dict[str, int]] = {}
+    minio = get_minio()
+
+    for doc_id, _source, minio_key, abstract in rows:
+        # Полный текст, если он сохранён; иначе то, что есть в базе
+        body = abstract or ""
+        if minio_key:
+            try:
+                obj = minio.get_object(settings.MINIO_BUCKET_DOCS, minio_key)
+                body = obj.read().decode("utf-8", errors="replace")
+                obj.close()
+                obj.release_conn()
+            except Exception:
+                pass
+        if len(body.split()) < args.words * 2:
+            continue
+
+        for case_name, work in make_cases(body, args.words).items():
+            found = find_source(work)
+            bucket = stats.setdefault(case_name, {"всего": 0, "нашли верно": 0, "не нашли": 0})
+            bucket["всего"] += 1
+            if doc_id in found:
+                bucket["нашли верно"] += 1
+            else:
+                bucket["не нашли"] += 1
+
+        # Контроль на ложные обвинения
+        found = find_source(original_text(rnd, args.words))
+        bucket = stats.setdefault("оригинал", {"всего": 0, "ложно обвинён": 0, "чисто": 0})
+        bucket["всего"] += 1
+        if found:
+            bucket["ложно обвинён"] += 1
+        else:
+            bucket["чисто"] += 1
+
+    print(f"{'случай':16} {'всего':>6} {'найден':>8} {'пропущен':>10}  доля найденных")
+    for case in ("дословно", "лёгкий рерайт", "сильный рерайт"):
+        b = stats.get(case)
+        if not b:
+            continue
+        share = b["нашли верно"] / b["всего"] * 100 if b["всего"] else 0
+        print(f"{case:16} {b['всего']:>6} {b['нашли верно']:>8} {b['не нашли']:>10}  {share:5.1f}%")
+
+    b = stats.get("оригинал")
+    if b:
+        fp_rate = b["ложно обвинён"] / b["всего"] * 100 if b["всего"] else 0
+        print(f"\nоригинальные тексты: {b['всего']}, ложных обвинений {b['ложно обвинён']} "
+              f"({fp_rate:.1f}%)")
+
+    print("\nЧитать так: «дословно» и «лёгкий рерайт» — обязанность L1, доля должна быть "
+          "близка к 100%. «Сильный рерайт» L1 брать не обязан, это работа L3/L4. "
+          "Ложные обвинения должны быть нулевыми.")
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/faiss_reconcile.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""Сверить отметки `documents.faiss_id` с реальным содержимым векторного индекса.
+
+Проблема, которую он решает: отметка в базе НЕ означает, что вектор есть в
+индексе. Она остаётся после пересоздания индекса (например, при смене модели
+эмбеддингов и размерности) и после сбоев worker-gpu. Из-за этого документ
+навсегда выпадает из L3: в индексе его нет, а на пересчёт он не попадёт —
+`reembed_missing.py` ищет только `faiss_id IS NULL`.
+
+Замер на проде 2026-08-28: в индексе 93 053 вектора, отмечено в базе 154 046 —
+60 993 документа считались векторизованными, не будучи ими.
+
+Скрипт обнуляет отметки у документов, которых в индексе нет. После него
+`reembed_missing.py` отправит их на пересчёт.
+
+Запуск (нужен доступ к самому индексу → контейнер worker-gpu):
+    cd /home/user/anti-plagiarism
+    C="docker compose -f docker-compose.prod.yml exec -T worker-gpu python -"
+    $C < scripts/ops/faiss_reconcile.py            # dry-run, только показывает
+    $C --apply < scripts/ops/faiss_reconcile.py    # обнулить ложные отметки
+
+Работает только с FAISS (`VECTOR_BACKEND=faiss`): у Qdrant идентификаторы
+хранит сам сервис, и сверка там делается иначе.
+"""
+
+import argparse
+import sys
+
+
+def stale_marks(marked_ids: set[int], indexed_ids: set[int]) -> set[int]:
+    """Документы, отмеченные как векторизованные, но отсутствующие в индексе."""
+    return marked_ids - indexed_ids
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--apply", action="store_true", help="реально обнулить faiss_id (иначе dry-run)")
+    args = ap.parse_args()
+
+    from app.config import settings
+
+    if settings.VECTOR_BACKEND != "faiss":
+        sys.exit(f"VECTOR_BACKEND={settings.VECTOR_BACKEND}: скрипт рассчитан на faiss")
+
+    import faiss  # noqa: F401  (нужен для vector_to_array)
+    from app.faiss_manager import FAISSManager
+
+    FAISSManager.load_or_create()
+    index = FAISSManager._index
+    if index is None or not hasattr(index, "id_map"):
+        sys.exit("индекс не загрузился или не хранит id (нет id_map)")
+
+    indexed = {int(i) for i in faiss.vector_to_array(index.id_map)}
+    print(f"векторов в индексе: {index.ntotal} (уникальных id: {len(indexed)})")
+
+    import psycopg2
+
+    conn = psycopg2.connect(
+        host=settings.POSTGRES_HOST, port=settings.POSTGRES_PORT,
+        dbname=settings.POSTGRES_DB, user=settings.POSTGRES_USER,
+        password=settings.POSTGRES_PASSWORD,
+    )
+    with conn.cursor() as cur:
+        cur.execute("SELECT id FROM documents WHERE faiss_id IS NOT NULL")
+        marked = {r[0] for r in cur.fetchall()}
+        cur.execute("SELECT count(*) FROM documents")
+        total = cur.fetchone()[0]
+
+    stale = stale_marks(marked, indexed)
+    print(f"документов всего:            {total}")
+    print(f"отмечено как векторизованные: {len(marked)}")
+    print(f"ложных отметок (нет в индексе): {len(stale)}")
+    print(f"реальное покрытие L3:         {len(indexed & marked) * 100.0 / total:.1f}%")
+
+    if not stale:
+        print("Сверка чистая, делать нечего.")
+        conn.close()
+        return
+
+    if not args.apply:
+        print(f"\n[dry-run] первые id: {sorted(stale)[:10]}")
+        print("Запустите с --apply, чтобы обнулить faiss_id у этих документов,")
+        print("затем reembed_missing.py отправит их на пересчёт эмбеддингов.")
+        conn.close()
+        return
+
+    ids = list(stale)
+    with conn.cursor() as cur:
+        # Пачками: один UPDATE с десятками тысяч id упирается в лимиты параметров
+        for i in range(0, len(ids), 5000):
+            chunk = ids[i : i + 5000]
+            cur.execute("UPDATE documents SET faiss_id = NULL WHERE id = ANY(%s)", (chunk,))
+    conn.commit()
+    conn.close()
+    print(f"\nОбнулено отметок: {len(ids)}")
+    print("Дальше: reembed_missing.py --apply (отправит их на пересчёт).")
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/keep_ingesting.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Держать массовую заливку идущей: перезапускать источники, когда они закончили.
+
+Массовый источник за один прогон берёт столько статей, сколько влезает в бюджет
+времени таска, сохраняет позицию и останавливается. Без внешнего толчка заливка
+идёт рывками — ровно столько, сколько раз кто-то нажмёт «Запустить». Этот скрипт
+и есть толчок: раз в несколько минут проверяет, не простаивает ли источник, и
+запускает следующую порцию.
+
+Ставится в cron на app-хосте:
+    */5 * * * * cd /home/user/anti-plagiarism && /usr/bin/docker compose \
+      -f docker-compose.prod.yml exec -T worker-indexer python - \
+      < scripts/ops/keep_ingesting.py >> ~/.antiplag-monitor/ingest.log 2>&1
+
+Останавливается сам, когда источник исчерпан: парсер перестаёт отдавать статьи,
+прогон закрывается с нулём добавленных, и скрипт больше его не трогает
+(--stop-when-empty, по умолчанию включено).
+
+Перед подсчётом «занято ли» снимает зависшие прогоны: если worker-indexer упал
+или перезапустился, прогон навсегда остаётся в статусе running с замолчавшим
+heartbeat — без этой чистки сторож видит «занято» бесконечно и не запускает
+вообще ничего, для всех источников сразу (порог тот же, что и в панели
+отладки — services/api/app/api/admin.py, stale_cutoff).
+
+Молчащий heartbeat сам по себе ещё не значит «мёртв»: пачка COPY на большой
+базе идёт десятки минут без единого тика. Поэтому прогон снимается, только
+если его таска нет среди выполняющихся на воркерах queue.index; не ответил
+хоть один такой воркер — не снимается ничего. Иначе сторож снимал живой
+медленный прогон и тут же запускал его дубль по тем же статьям.
+"""
+
+import argparse
+
+BULK_TYPES = ("wikipedia_ru", "pmc_bulk", "core")
+STALE_MINUTES = 10
+
+
+def live_task_ids(celery_app) -> set[str] | None:
+    """ID тасков, выполняющихся на воркерах queue.index; None — кто-то из них не ответил."""
+    queues = celery_app.control.inspect(timeout=10).active_queues() or {}
+    workers = [w for w, qs in queues.items() if any(q["name"] == "queue.index" for q in qs)]
+    if not workers:
+        return None
+    active = celery_app.control.inspect(destination=workers, timeout=10).active()
+    if not active or set(active) != set(workers):
+        return None
+    return {t["id"] for tasks in active.values() for t in tasks}
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--types", default=",".join(BULK_TYPES),
+                    help="типы источников через запятую")
+    ap.add_argument("--keep-going-empty", action="store_true",
+                    help="запускать даже если прошлый прогон ничего не добавил")
+    args = ap.parse_args()
+
+    from app.celery_app import celery_app
+    from app.db import db_session
+    from app.models import ParseRun, ParseSource
+    from sqlalchemy import text
+
+    types = tuple(t.strip() for t in args.types.split(",") if t.strip())
+
+    live = live_task_ids(celery_app)
+
+    with db_session() as s:
+        if live is None:
+            print("воркеры queue.index не ответили — живость прогонов не проверить, не снимаю")
+            reaped = []
+        else:
+            reaped = s.execute(text(f"""
+                UPDATE parse_runs SET status='error', stage='finished',
+                       error='зависший прогон снят автоматически: таск не выполняется, heartbeat молчал дольше {STALE_MINUTES} минут',
+                       finished_at=now()
+                WHERE status='running'
+                  AND (heartbeat_at IS NULL OR heartbeat_at < now() - interval '{STALE_MINUTES} minutes')
+                  AND (celery_task_id IS NULL OR NOT (celery_task_id = ANY(CAST(:live AS text[]))))
+                RETURNING id, source_id
+            """), {"live": sorted(live)}).all()
+        # queued без heartbeat — тот же зомби другого вида: send_task не дошёл
+        # или упал между двумя commit при постановке в очередь (celery_task_id
+        # так и остался пустым), воркер о такой задаче никогда не узнает
+        reaped += s.execute(text(f"""
+            UPDATE parse_runs SET status='error', stage='finished',
+                   error='зависший прогон снят автоматически: висел в очереди дольше {STALE_MINUTES} минут',
+                   finished_at=now()
+            WHERE status='queued'
+              AND celery_task_id IS NULL
+              AND started_at < now() - interval '{STALE_MINUTES} minutes'
+            RETURNING id, source_id
+        """)).all()
+        if reaped:
+            for source_id in {row.source_id for row in reaped}:
+                s.execute(text("""
+                    UPDATE parse_sources SET last_status='error',
+                           last_error='зависший прогон снят автоматически'
+                    WHERE id=:sid AND last_status='running'
+                """), {"sid": source_id})
+            s.commit()
+            print(f"снято зависших прогонов: {len(reaped)} ({', '.join(str(r.id) for r in reaped)})")
+
+        active = s.execute(text(
+            "SELECT count(*) FROM parse_runs WHERE status IN ('queued','running')"
+        )).scalar_one()
+        if active:
+            print(f"уже идёт прогонов: {active} — ждём")
+            return
+
+        sources = s.execute(text("""
+            SELECT id, source_type, last_run_id FROM parse_sources
+            WHERE enabled AND source_type = ANY(:types) ORDER BY id
+        """), {"types": list(types)}).all()
+
+        started = []
+        for source_id, source_type, last_run_id in sources:
+            # Источник исчерпан, если прогоны перестали добавлять статьи: дальше
+            # в дампе/бакете/выдаче для нас ничего нет.
+            #
+            # Но ОДИН пустой прогон — ещё не приговор: ровно так же выглядят
+            # обрыв связи с API и прогон на устаревшем коде парсера. На CORE
+            # 16.09.2026 из-за этого источник был помечен исчерпанным после
+            # единственной неудачи и больше не запускался — молча, без ошибки.
+            # Поэтому ждём два пустых прогона подряд: разовый сбой переживём,
+            # а реально кончившийся источник остановится всего на один прогон
+            # позже.
+            if last_run_id and not args.keep_going_empty:
+                last_two = s.execute(text("""
+                    SELECT status, added, fetched FROM parse_runs
+                    WHERE source_id = :sid ORDER BY id DESC LIMIT 2
+                """), {"sid": source_id}).all()
+                if len(last_two) == 2 and all(
+                    r.status == "done" and r.added == 0 and r.fetched == 0 for r in last_two
+                ):
+                    print(f"{source_type}: источник исчерпан (два пустых прогона), пропускаем")
+                    continue
+
+            src = s.get(ParseSource, source_id)
+            run = ParseRun(source_id=source_id, status="queued", stage="queued",
+                           target=src.limit, log=[])
+            s.add(run)
+            s.flush()
+
+            src.last_status = "running"
+            src.last_error = None
+            src.last_run_id = run.id
+            s.commit()
+
+            result = celery_app.send_task("index.run_parser", args=[source_id, run.id],
+                                          queue="queue.index")
+            run.celery_task_id = result.id
+            s.commit()
+            started.append(f"{source_type}(прогон {run.id})")
+
+    print("запущено:", ", ".join(started) if started else "нечего запускать")
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/reembed_missing.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Догнать эмбеддинги для документов, у которых их нет (faiss_id IS NULL).
+
+Зачем: документ попадает в корпус сразу (метаданные, fingerprints L1, MinHash L2),
+а вектор для L3 считает отдельная задача `gpu.embed_documents`. Если worker-gpu
+или Ollama были недоступны в момент заливки, эти задачи теряются — документ
+остаётся в базе, но семантический поиск его не видит. Скрипт находит такие
+документы и переотправляет задачи пачками.
+
+Идемпотентно: повторный запуск возьмёт только оставшиеся без faiss_id.
+
+ВАЖНО, чего скрипт НЕ делает: документы с непустым `faiss_id`, которого нет в
+самом FAISS-индексе (наследие смены модели эмбеддингов — размерность сменилась,
+индекс пересобран с нуля, а ссылки в БД остались), сюда не попадут. Их сначала
+надо выявить сверкой с индексом и обнулить faiss_id — это отдельная операция.
+
+Запуск (нужны psycopg2 + celery — они есть в образе воркера; сам репозиторий
+внутрь контейнера не смонтирован, поэтому передаём скрипт через stdin):
+    cd /home/user/anti-plagiarism
+    C="docker compose -f docker-compose.prod.yml exec -T worker-indexer python -"
+    $C < scripts/ops/reembed_missing.py                    # dry-run, только считает
+    $C --apply < scripts/ops/reembed_missing.py            # отправить задачи
+    $C --apply --limit 1000 < scripts/ops/reembed_missing.py   # пробная порция
+
+Креды берутся из окружения (в контейнере они уже есть из env_file), а при
+запуске файлом — из .env репозитория: POSTGRES_*, RABBITMQ_URL.
+"""
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+DEFAULT_BATCH = 64  # столько же, сколько EMBED_BATCH_SIZE у индексера
+
+
+def _load_env() -> None:
+    """Подтянуть переменные из .env репозитория, если файл есть.
+
+    При запуске через stdin (`docker exec ... python -`) __file__ не определён —
+    это штатный способ запуска здесь, и переменные в контейнере уже есть.
+    """
+    try:
+        env = Path(__file__).resolve().parent.parent.parent / ".env"
+    except NameError:
+        return
+    if not env.exists():
+        return
+    for line in env.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, val = line.partition("=")
+        os.environ.setdefault(key.strip(), val.strip())
+
+
+def _pg_dsn() -> dict:
+    return {
+        "host": os.environ.get("POSTGRES_HOST", "localhost"),
+        "port": int(os.environ.get("POSTGRES_PORT", "5432")),
+        "dbname": os.environ.get("POSTGRES_DB", "antiplagiator"),
+        "user": os.environ.get("POSTGRES_USER", "antiplagiator"),
+        "password": os.environ.get("POSTGRES_PASSWORD", ""),
+    }
+
+
+def chunked(items: list[int], size: int) -> list[list[int]]:
+    """Разбить список id на пачки по size элементов."""
+    return [items[i : i + size] for i in range(0, len(items), size)]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
+    )
+    ap.add_argument("--apply", action="store_true", help="реально отправить задачи (иначе dry-run)")
+    ap.add_argument("--batch", type=int, default=DEFAULT_BATCH, help=f"документов в пачке (по умолчанию {DEFAULT_BATCH})")
+    ap.add_argument("--limit", type=int, default=0, help="взять не больше N документов (0 = все)")
+    args = ap.parse_args()
+
+    _load_env()
+
+    try:
+        import psycopg2
+    except ImportError:
+        sys.exit("Нужен psycopg2 (есть в образах воркеров). Запускайте в контейнере.")
+
+    dsn = _pg_dsn()
+    print(f"PostgreSQL {dsn['host']}:{dsn['port']}/{dsn['dbname']}")
+    conn = psycopg2.connect(**dsn)
+    with conn.cursor() as cur:
+        sql = "SELECT id FROM documents WHERE faiss_id IS NULL ORDER BY id"
+        if args.limit:
+            sql += f" LIMIT {int(args.limit)}"
+        cur.execute(sql)
+        doc_ids = [r[0] for r in cur.fetchall()]
+
+        cur.execute("SELECT count(*) FROM documents")
+        total = cur.fetchone()[0]
+    conn.close()
+
+    batches = chunked(doc_ids, args.batch)
+    print(f"Документов всего: {total}")
+    print(f"Без эмбеддинга:   {len(doc_ids)} → пачек по {args.batch}: {len(batches)}")
+    if not doc_ids:
+        print("Нечего досчитывать.")
+        return
+
+    if not args.apply:
+        head = ", ".join(str(i) for i in doc_ids[:10])
+        print(f"\n[dry-run] первые id: {head}{' …' if len(doc_ids) > 10 else ''}")
+        print("Запустите с --apply, чтобы отправить gpu.embed_documents в queue.gpu.")
+        return
+
+    try:
+        from celery import Celery
+    except ImportError:
+        sys.exit("Нужен celery (есть в образах воркеров). Запускайте в контейнере.")
+
+    broker = os.environ.get("RABBITMQ_URL")
+    if not broker:
+        sys.exit("Не задан RABBITMQ_URL — нечем отправлять задачи.")
+
+    app = Celery("reembed", broker=broker)
+    sent = 0
+    try:
+        for batch in batches:
+            app.send_task("gpu.embed_documents", args=[batch], queue="queue.gpu")
+            sent += 1
+            if sent % 50 == 0:
+                print(f"  отправлено пачек: {sent}/{len(batches)}")
+    except Exception as e:
+        sys.exit(f"\nБрокер недоступен после {sent} пачек: {e}")
+
+    print(f"\nОтправлено пачек: {sent} ({len(doc_ids)} документов).")
+    print("Ход выполнения — админка → «Отладка» (очередь queue.gpu и покрытие эмбеддингами).")
+
+
+if __name__ == "__main__":
+    main()

scripts/ops/wikipedia_resume_offset.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Вычислить байтовое смещение в дампе Википедии по уже залитым статьям.
+
+Нужен один раз при переходе на multistream-дамп: позиция продолжения сменила
+смысл — раньше это был номер статьи (и прогон перечитывал дамп с начала),
+теперь байтовое смещение блока.
+
+Как считается: берём максимальный page_id среди залитых статей и находим в
+индексе дампа блок, которому он принадлежит. Страницы в дампе идут по
+возрастанию page_id, поэтому всё, что дальше этого блока, ещё не залито.
+
+Запуск (в контейнере worker-indexer):
+    docker compose -f docker-compose.prod.yml exec -T worker-indexer python - \\
+        < scripts/ops/wikipedia_resume_offset.py            # показать
+    ... python - --apply < scripts/ops/wikipedia_resume_offset.py   # записать
+"""
+
+import argparse
+import bz2
+import os
+
+DEFAULT_INDEX = "/parsers/ruwiki-index.txt.bz2"
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--apply", action="store_true", help="записать смещение в источник")
+    ap.add_argument("--index", default=DEFAULT_INDEX, help="путь к индексу дампа")
+    args = ap.parse_args()
+
+    from app.db import db_session
+    from sqlalchemy import text
+
+    if not os.path.exists(args.index):
+        raise SystemExit(f"индекс не найден: {args.index}")
+
+    with db_session() as s:
+        row = s.execute(text("""
+            SELECT max(split_part(ext_id, ':', 2)::bigint)
+            FROM documents WHERE source = 'wikipedia_ru'
+        """)).first()
+    max_pageid = int(row[0]) if row and row[0] else 0
+    print(f"максимальный page_id среди залитых: {max_pageid}")
+
+    if not max_pageid:
+        print("залитых статей нет — начинать с нуля")
+        return
+
+    # Индекс отсортирован по смещению, page_id внутри растут: ищем блок,
+    # в котором лежит наш максимальный, и берём его смещение
+    offset = 0
+    found_title = ""
+    with bz2.open(args.index, "rt", encoding="utf-8") as fh:
+        for line in fh:
+            parts = line.split(":", 2)
+            if len(parts) < 3:
+                continue
+            off, pid = int(parts[0]), int(parts[1])
+            if pid > max_pageid:
+                break
+            offset, found_title = off, parts[2].strip()
+
+    print(f"блок с этой статьёй начинается на байте {offset} ({found_title[:50]!r})")
+
+    if not args.apply:
+        print("\nзапустите с --apply, чтобы записать смещение в источник")
+        return
+
+    with db_session() as s:
+        s.execute(text("""
+            UPDATE parse_sources SET resume_token = :off WHERE source_type = 'wikipedia_ru'
+        """), {"off": str(offset)})
+        s.commit()
+    print(f"смещение {offset} записано в источник")
+
+
+if __name__ == "__main__":
+    main()

scripts/parsers/core.py

@@ -0,0 +1,282 @@
+"""Парсер CORE (core.ac.uk) — полные тексты открытых репозиториев.
+
+Зачем нужен: полный текст есть у малой доли корпуса, и по-русски дыра самая
+большая — CyberLeninka отдаёт только HTML-страницу статьи, тела не даёт. CORE
+агрегирует открытые репозитории (в том числе вузовские русско- и
+белорусскоязычные) и кладёт готовый текст прямо в выдачу поиска — его не надо
+ни скачивать отдельно, ни извлекать из PDF.
+
+Замер на живом API 16.09.2026: страница в 100 записей приходит за ~7с и
+содержит 47 статей с текстом длиннее 1500 символов, медиана — 12.7 тыс.
+символов. То есть один запрос ≈ 47 документов корпуса.
+
+Чем сузить выборку до русских текстов: в общем потоке CORE кириллицы нет
+вовсе (проверено: 0 из 48 полных текстов за 2019). Язык у работ размечен
+плохо — `language` сплошь None или "zz", фильтровать по нему нельзя. Зато
+работает отбор по архиву-поставщику: запрос вида
+`(repositories.id:1298 OR repositories.id:21908 OR ...)` по вузовским
+репозиториям России и Беларуси даёт 79 полных текстов из 100 записей, 78 из
+них — кириллица. Сам список архивов живёт в поле `query` источника, а не в
+коде: его правят из админки, не пересобирая образ.
+
+Массовый парсер (`bulk = True`): отдаёт статьи генератором и пишется пачками
+через COPY, как Википедия и PMC (см. bulk_writer.py). Статьи без текста
+пропускаются молча — они уже есть у нас как метаданные из OpenAlex, а
+обогащать корпус нечем.
+
+Грабли API, все проверены живьём:
+- **с российских адресов ключ не работает**: прямой запрос с прода виснет без
+  ошибки (соединение есть, тело ответа не приходит), через `singbox-proxy` тот
+  же запрос отвечает за 1.7с. Анонимные короткие запросы проходят и напрямую,
+  из-за чего поломка выглядит как сетевая. Адрес прокси — `CORE_PROXY_URL`;
+- у `/v3/search/works` обязателен слэш на конце: иначе 301, а при редиректе
+  теряется заголовок Authorization и запрос уходит анонимным;
+- `offset` упирается в 100 000 (под капотом Azure Search, глубже — 400),
+  поэтому выборка режется на части — по одному архиву-поставщику на запрос;
+- **условия через `AND` не связываются**: `(repositories.id:...) AND yearPublished:2026`
+  отдаёт 2.3 млн работ вперемешку по годам, то есть условия объединяются по
+  «или» и год работает лишь как подсказка ранжированию. По отдельности каждое
+  условие фильтрует честно (`yearPublished:2026` — ровно 2026, `repositories.id:1298`
+  — ровно этот архив). Поэтому в запрос идёт РОВНО ОДНО условие: номер архива.
+  Годы, если заданы, отсекаются уже на нашей стороне;
+- `fullText` — не фильтруемое поле, `_exists_:fullText` отвечает 500.
+  Отбирать статьи с текстом приходится на своей стороне, оплачивая трафиком;
+- CORE агрегирует репозитории и отдаёт одну статью несколько раз под разными
+  id (проверено: 90810208 и 354263199 — один текст). Дедупликация корпуса
+  идёт только по ext_id, поэтому такие пары легли бы отдельными документами
+  и потом ловились бы как заимствование друг у друга. Отсеиваем по хешу
+  текста в пределах прогона: копии приходят в соседних строках выдачи.
+"""
+
+import hashlib
+import logging
+import os
+import re
+import time
+from collections.abc import Iterator
+from typing import Any
+
+import httpx
+from base import BaseParser, ProgressCallback
+
+logger = logging.getLogger(__name__)
+
+API_URL = "https://api.core.ac.uk/v3/search/works/"   # слэш обязателен, см. докстринг
+PAGE = 100              # максимум записей за запрос
+MAX_OFFSET = 100_000    # потолок глубины у Azure Search
+MIN_CHARS = 1500        # короче — обрывок или аннотация, а не статья
+RETRIES = 3
+# CORE отдаёт данные по ключу только за пределами РФ: с прода прямой запрос
+# молча виснет (TCP есть, тело ответа не приходит), а тот же запрос через
+# sing-box возвращается за 1.7с. Анонимные мелкие запросы проходят и напрямую,
+# поэтому со стороны это выглядит как поломка сети, а не блокировка. Тот же
+# приём, что для OpenRouter в worker-gpu. Пусто = ходить напрямую.
+DEFAULT_PROXY = "socks5://singbox-proxy:1080"
+
+
+class COREParser(BaseParser):
+    """Полные тексты из CORE. Отдаёт статьи потоком, режет выборку по годам."""
+
+    source_name = "core"
+    bulk = True
+
+    def __init__(self, api_key: str | None = None, proxy_url: str | None = None) -> None:
+        super().__init__()
+        self.api_key = api_key or os.environ.get("CORE_API_KEY", "")
+        # Вне compose-сети (локальный прогон, тесты) имени singbox-proxy нет —
+        # там прокси отключают, выставив CORE_PROXY_URL пустым
+        self.proxy_url = self._proxy(proxy_url)
+        if not self.api_key:
+            logger.warning("CORE: ключ не задан (CORE_API_KEY) — API ответит 401")
+        # Страница весит ~5 МБ, обычный ответ ~7с. 30с — запас на джиттер в
+        # десять раз, но без риска съесть бюджет прогона: три попытки по 60с
+        # отъедали 180с из 1500с на одной залипшей странице (поймано 16.09.2026,
+        # та же грабля, что чинили в pmc_bulk)
+        self.client = httpx.Client(
+            timeout=30,
+            proxy=self.proxy_url or None,
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "User-Agent": "AcademicHelper/1.0 (noreply@jze9.ru)",
+            },
+        )
+        self.last_token: str | None = None
+
+    @staticmethod
+    def _proxy(proxy_url: str | None) -> str:
+        """Адрес прокси: явный аргумент, иначе CORE_PROXY_URL, иначе умолчание."""
+        if proxy_url is not None:
+            return proxy_url
+        return os.environ.get("CORE_PROXY_URL", DEFAULT_PROXY)
+
+    def fetch(  # type: ignore[override]
+        self,
+        limit: int = 1000,
+        query: str = "",
+        year_from: int | None = None,
+        year_to: int | None = None,
+        resume_token: str | None = None,
+        progress_cb: ProgressCallback | None = None,
+        **_ignored: Any,
+    ) -> Iterator[dict[str, Any]]:
+        """Статьи с полным текстом, архив за архивом.
+
+        Args:
+            limit: сколько статей с текстом отдать за прогон
+            query: список архивов — номера через запятую/пробел или выражение
+                `(repositories.id:N OR ...)`. Пустой — обычный поиск по словам
+            year_from: отсекать статьи старше этого года (необязательно)
+            year_to: отсекать статьи новее этого года (необязательно)
+            resume_token: позиция вида "1298:4200" — архив и смещение в нём
+            progress_cb: см. base.ProgressCallback
+        """
+        parts = self._repos(query)
+        start_part, start_offset = self._parse_token(resume_token)
+        if start_part in parts:
+            parts = parts[parts.index(start_part):]
+        else:
+            start_offset = 0
+
+        given = 0
+        seen: set[str] = set()
+        for part in parts:
+            offset = start_offset
+            start_offset = 0      # смещение относится только к архиву из токена
+
+            while given < limit and offset < MAX_OFFSET:
+                results = self._page(part, query, offset)
+                if results is None:      # API не ответил — прогон закончен
+                    return
+                if not results:
+                    logger.info("CORE: архив %s исчерпан на смещении %d", part, offset)
+                    break
+
+                token = f"{part}:{offset}"
+                for work in results:
+                    text = work.get("fullText") or ""
+                    if len(text) < MIN_CHARS:
+                        continue
+                    year = work.get("yearPublished")
+                    if year and ((year_from and year < year_from)
+                                 or (year_to and year > year_to)):
+                        continue
+                    # Дубли CORE: один текст под разными id (см. докстринг).
+                    # Хеша начала текста хватает — совпадение первых 5 тыс.
+                    # символов у разных статей практически исключено
+                    digest = hashlib.sha1(text[:5000].encode()).hexdigest()
+                    if digest in seen:
+                        continue
+                    seen.add(digest)
+                    given += 1
+                    # Токен указывает на страницу, из которой пришла статья, а
+                    # не на следующую: пачка может прерваться на её середине, и
+                    # тогда следующий прогон перечитает страницу целиком.
+                    # Лишний запрос дешевле потерянных статей, дубли отсекает
+                    # ON CONFLICT на ext_id
+                    work["resume_token"] = token
+                    yield work
+                    if given >= limit:
+                        break
+
+                offset += PAGE
+                self.last_token = f"{part}:{offset}"
+                if progress_cb and not progress_cb(given):
+                    logger.info("CORE: выборка остановлена по запросу (%d)", given)
+                    return
+
+        logger.info("CORE: пройдено архивов: %d, отдано %d", len(parts), given)
+
+    @staticmethod
+    def _repos(query: str) -> list[str]:
+        """Номера архивов из настройки источника.
+
+        Принимает и выражение `(repositories.id:1298 OR ...)`, и простой список
+        «1298, 21908». Если номеров нет вовсе — единственная часть с именем
+        `q`: тогда парсер просто ищет по словам запроса.
+        """
+        ids = re.findall(r"repositories\.id:(\d+)", query or "")
+        if not ids:
+            ids = re.findall(r"\b\d{2,7}\b", query or "")
+        return ids or ["q"]
+
+    @staticmethod
+    def _parse_token(token: str | None) -> tuple[str | None, int]:
+        """Разобрать позицию "архив:смещение"; мусор — начать сначала."""
+        if not token or ":" not in token:
+            return None, 0
+        part, _, offset = token.rpartition(":")
+        try:
+            return part, int(offset)
+        except ValueError:
+            logger.warning("CORE: непонятная позиция %r, начинаем сначала", token)
+            return None, 0
+
+    def _page(self, part: str, query: str, offset: int) -> list[dict[str, Any]] | None:
+        """Одна страница выдачи; None — API не отвечает, прогон пора кончать.
+
+        В запросе РОВНО одно условие: связка через AND в этом API не работает
+        (см. докстринг модуля), поэтому годы отсекаются уже после выборки.
+        """
+        q = f"repositories.id:{part}" if part != "q" else (query or "*")
+        params = {"q": q, "limit": PAGE, "offset": offset}
+
+        for attempt in range(RETRIES):
+            try:
+                resp = self.client.get(API_URL, params=params)
+                if resp.status_code == 429:
+                    # Лимит тарифа: подождать и повторить, а не ронять прогон
+                    wait = int(resp.headers.get("retry-after", 30))
+                    logger.warning("CORE: лимит запросов, ждём %dс", wait)
+                    time.sleep(min(wait, 60))
+                    continue
+                resp.raise_for_status()
+                return resp.json().get("results") or []
+            except Exception as e:
+                logger.warning(
+                    "CORE: страница %s:%d не удалась (%d/%d): %s",
+                    part, offset, attempt + 1, RETRIES, e,
+                )
+                time.sleep(2 * (attempt + 1))
+
+        logger.error("CORE: страница %s:%d не далась за %d попыток", part, offset, RETRIES)
+        return None
+
+    def transform(self, raw: dict[str, Any]) -> dict[str, Any]:
+        """Привести статью CORE к унифицированному формату корпуса."""
+        ext = raw.get("id")
+        text = raw.get("fullText") or ""
+        if not ext or len(text) < MIN_CHARS:
+            return {}
+
+        lang = raw.get("language") or {}
+        code = lang.get("code") if isinstance(lang, dict) else lang
+        journals = raw.get("journals") or []
+        journal = journals[0].get("title") if journals and isinstance(journals[0], dict) else None
+
+        return {
+            "source": self.source_name,
+            "ext_id": f"core:{ext}",
+            "title": (raw.get("title") or f"CORE {ext}")[:1000],
+            "authors": self.normalize_authors(self._authors(raw)),
+            "doi": raw.get("doi"),
+            "year": raw.get("yearPublished"),
+            # zz у CORE значит «язык не определён» — лучше пусто, чем мусор
+            "lang": code if code and code != "zz" else None,
+            "journal": journal[:300] if journal else None,
+            "url": raw.get("downloadUrl") or f"https://core.ac.uk/works/{ext}",
+            "abstract": (raw.get("abstract") or text[:2000])[:2000],
+            "text": text,
+            "resume_token": raw.get("resume_token"),
+        }
+
+    @staticmethod
+    def _authors(raw: dict[str, Any]) -> list[dict[str, str]]:
+        """Авторы CORE приходят одной строкой "Фамилия, Имя Отчество"."""
+        out = []
+        for author in raw.get("authors") or []:
+            name = author.get("name") if isinstance(author, dict) else author
+            if not name:
+                continue
+            last, _, first = str(name).partition(",")
+            out.append({"last_name": last.strip(), "first_name": first.strip()})
+        return out

scripts/parsers/pmc_bulk.py

@@ -0,0 +1,164 @@
+"""Парсер PubMed Central из открытого бакета AWS — массовый путь.
+
+Отличие от `pmc.py`: тот ходит в API E-utilities и годится для точечной
+докачки по теме (1-2 статьи в секунду, есть rate limit). Этот берёт статьи из
+бакета `pmc-oa-opendata`, где у каждой лежит **уже извлечённый текст**, и
+качает их пачками в несколько потоков — путь к сотням тысяч и миллионам.
+
+Ключ для доступа не нужен, бакет открыт. Замер: 12 статей/с в 10 потоков.
+
+Как и парсер Википедии, отдаёт статьи генератором: складывать миллионы
+документов в список нельзя (см. bulk_writer.py).
+"""
+
+import logging
+import re
+from collections.abc import Iterator
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+from base import BaseParser, ProgressCallback
+
+logger = logging.getLogger(__name__)
+
+BUCKET = "https://pmc-oa-opendata.s3.amazonaws.com"
+KEY_RE = re.compile(r"<Key>(PMC\d+\.\d+)/\1\.txt</Key>")
+TOKEN_RE = re.compile(r"<NextContinuationToken>([^<]+)</NextContinuationToken>")
+YEAR_RE = re.compile(r"\b(19|20)\d{2}\b")
+MIN_CHARS = 1500        # меньше — обрывок, а не статья
+
+
+class PMCBulkParser(BaseParser):
+    """PMC Open Access из бакета AWS. Отдаёт статьи потоком."""
+
+    source_name = "pmc"     # тот же источник в корпусе, что и у API-парсера
+    bulk = True
+
+    def __init__(self, workers: int = 12) -> None:
+        super().__init__()
+        self.workers = workers
+        # 60с на файл при бюджете задачи в 1500с — один залипший запрос съедал
+        # почти весь бюджет. Обычный GET сюда укладывается в доли секунды,
+        # 12с — с большим запасом на джиттер, но без риска съесть весь прогон
+        self.client = httpx.Client(
+            timeout=12,
+            headers={"User-Agent": "AcademicHelper/1.0 (noreply@jze9.ru)"},
+        )
+        # Позиция листинга: бакет отдаётся страницами, и продолжать прогон
+        # нужно с той же страницы, а не с начала
+        self.last_token: str | None = None
+
+    def fetch(  # type: ignore[override]
+        self,
+        limit: int = 1000,
+        resume_token: str | None = None,
+        start_after: str | None = None,
+        progress_cb: ProgressCallback | None = None,
+        **_ignored: Any,
+    ) -> Iterator[dict[str, Any]]:
+        """Статьи из бакета: листинг страницами, скачивание в потоках.
+
+        Args:
+            limit: сколько статей отдать
+            resume_token: продолжить листинг с сохранённой страницы бакета
+            start_after: ключ, после которого начинать листинг. Нужен, когда
+                токена нет (первый прогон после ручных заливок): без него
+                листинг пошёл бы с начала бакета и часами перемалывал уже
+                залитые статьи как дубли
+            progress_cb: см. base.ProgressCallback
+        """
+        token = resume_token
+        given = 0
+
+        while given < limit:
+            try:
+                ids, token = self._list_page(
+                    token, want=min(200, limit - given),
+                    start_after=None if token else start_after,
+                )
+            except Exception as e:
+                logger.error("PMC bulk: листинг не удался: %s", e)
+                return
+            if not ids:
+                logger.info("PMC bulk: бакет закончился")
+                return
+
+            # as_completed вместо map(): map() отдаёт результаты строго по
+            # порядку отправки, поэтому один залипший запрос блокирует все
+            # уже готовые — даже если остальные 11 потоков давно отработали
+            with ThreadPoolExecutor(max_workers=self.workers) as pool:
+                futures = {pool.submit(self._fetch_article, i): i for i in ids}
+                for future in as_completed(futures):
+                    raw = future.result()
+                    if raw is None:
+                        continue
+                    given += 1
+                    raw["resume_token"] = token
+                    yield raw
+                    if given >= limit:
+                        break
+
+            self.last_token = token
+            if progress_cb and not progress_cb(given):
+                logger.info("PMC bulk: выборка остановлена по запросу (%d)", given)
+                return
+            if token is None:
+                return
+
+    def _list_page(
+        self, token: str | None, want: int, start_after: str | None = None
+    ) -> tuple[list[str], str | None]:
+        """Одна страница листинга бакета: id статей и токен следующей страницы."""
+        url = f"{BUCKET}/?list-type=2&max-keys=1000"
+        if token:
+            # В токене бывают + и / — без экранирования S3 отвечает 400
+            url += f"&continuation-token={quote(token, safe='')}"
+        elif start_after:
+            url += f"&start-after={quote(start_after, safe='')}"
+        resp = self.client.get(url)
+        resp.raise_for_status()
+        ids = KEY_RE.findall(resp.text)[:want]
+        m = TOKEN_RE.search(resp.text)
+        return ids, (m.group(1) if m else None)
+
+    def _fetch_article(self, art_id: str) -> dict[str, Any] | None:
+        """Текст статьи и метаданные; None — статья недоступна или пустая."""
+        try:
+            txt = self.client.get(f"{BUCKET}/{art_id}/{art_id}.txt")
+            if txt.status_code != 200 or len(txt.text) < MIN_CHARS:
+                return None
+            meta_resp = self.client.get(f"{BUCKET}/{art_id}/{art_id}.json")
+            meta = meta_resp.json() if meta_resp.status_code == 200 else {}
+        except Exception:
+            return None
+
+        return {"art_id": art_id, "meta": meta, "text": txt.text}
+
+    def transform(self, raw: dict[str, Any]) -> dict[str, Any]:
+        """Привести статью к унифицированному формату документов корпуса."""
+        meta = raw.get("meta") or {}
+        art_id = raw.get("art_id", "")
+        pmcid = meta.get("pmcid") or art_id.split(".")[0]
+        if not pmcid:
+            return {}
+
+        citation = meta.get("citation") or ""
+        year_match = YEAR_RE.search(citation)
+        text = raw.get("text", "")
+
+        return {
+            "source": self.source_name,
+            "ext_id": f"pmc:{pmcid}",
+            "title": (meta.get("title") or pmcid)[:1000],
+            "authors": [],
+            "doi": meta.get("doi"),
+            "year": int(year_match.group(0)) if year_match else None,
+            "lang": "en",
+            "journal": citation[:300] or None,
+            "url": f"https://www.ncbi.nlm.nih.gov/pmc/articles/{pmcid}/",
+            "abstract": text[:2000],
+            "text": text,
+            "resume_token": raw.get("resume_token"),
+        }

scripts/parsers/tests/test_core.py

@@ -0,0 +1,156 @@
+"""Юнит-тесты парсера CORE — чистая логика, без сети.
+
+Стерегут то, ради чего парсер написан иначе остальных: отбор статей с полным
+текстом, отсев дублей CORE (одна статья под разными id), нарезку выборки по
+архивам-поставщикам и позицию продолжения «архив:смещение».
+
+Нарезка по архивам — не украшение: связка условий через `AND` в API CORE не
+работает (запрос по архивам вместе с годом отдаёт годы вперемешку), поэтому в
+запрос идёт ровно одно условие, а годы отсекаются уже на нашей стороне.
+"""
+
+from core import DEFAULT_PROXY, MIN_CHARS, COREParser
+
+LONG = "слово " * 400        # заведомо длиннее MIN_CHARS
+
+SAMPLE = {
+    "id": 123456,
+    "title": "Нейронные сети в медицине",
+    "authors": [{"name": "Кузьмин, Ярослав Вадимович"}, {"name": "Савенок А."}],
+    "doi": "10.1234/x",
+    "yearPublished": 2019,
+    "language": {"code": "ru"},
+    "journals": [{"title": "Вестник"}],
+    "downloadUrl": "https://core.ac.uk/download/1.pdf",
+    "abstract": "Аннотация",
+    "fullText": LONG,
+    "resume_token": "1298:100",
+}
+
+
+def test_repos_from_or_expression():
+    q = "(repositories.id:1298 OR repositories.id:21908 OR repositories.id:949)"
+    assert COREParser._repos(q) == ["1298", "21908", "949"]
+
+
+def test_repos_from_plain_list():
+    assert COREParser._repos("1298, 21908 949") == ["1298", "21908", "949"]
+
+
+def test_repos_without_numbers_falls_back_to_word_search():
+    # Номеров нет — единственная часть «q»: обычный поиск по словам
+    assert COREParser._repos("нейронные сети") == ["q"]
+    assert COREParser._repos("") == ["q"]
+
+
+def test_parse_token():
+    assert COREParser._parse_token("1298:4200") == ("1298", 4200)
+    assert COREParser._parse_token("q:300") == ("q", 300)
+    assert COREParser._parse_token(None) == (None, 0)
+    assert COREParser._parse_token("мусор") == (None, 0)
+    assert COREParser._parse_token("архив:смещение") == (None, 0)
+
+
+def test_transform_maps_fields():
+    t = COREParser(proxy_url="").transform(SAMPLE)
+    assert t["ext_id"] == "core:123456"
+    assert t["source"] == "core"
+    assert t["year"] == 2019 and t["lang"] == "ru"
+    assert t["journal"] == "Вестник"
+    assert t["text"] == LONG
+    assert t["resume_token"] == "1298:100"
+    # Автор приходит одной строкой «Фамилия, Имя Отчество»
+    assert t["authors"][0]["last_name"] == "Кузьмин"
+    assert t["authors"][0]["initials"] == "Я.В."
+
+
+def test_transform_skips_short_text():
+    assert COREParser(proxy_url="").transform(dict(SAMPLE, fullText="коротко")) == {}
+    assert COREParser(proxy_url="").transform(dict(SAMPLE, fullText=None)) == {}
+    assert COREParser(proxy_url="").transform(dict(SAMPLE, id=None)) == {}
+
+
+def test_transform_drops_undefined_language():
+    # zz у CORE значит «язык не определён» — в корпус такое класть незачем
+    assert COREParser(proxy_url="").transform(dict(SAMPLE, language={"code": "zz"}))["lang"] is None
+    assert COREParser(proxy_url="").transform(dict(SAMPLE, language=None))["lang"] is None
+
+
+def _parser_with_pages(pages):
+    """Парсер, у которого выдача подменена заранее заготовленными страницами."""
+    p = COREParser(api_key="test", proxy_url="")
+    calls = []
+
+    def fake_page(part, query, offset):
+        calls.append((part, offset))
+        return pages.pop(0) if pages else []
+
+    p._page = fake_page       # type: ignore[method-assign]
+    p.calls = calls           # type: ignore[attr-defined]
+    return p
+
+
+def test_fetch_drops_core_duplicates():
+    # Одна и та же статья под разными id — CORE так отдаёт всегда
+    page = [
+        {"id": 1, "fullText": LONG},
+        {"id": 2, "fullText": LONG},
+        {"id": 3, "fullText": LONG + "иное"},
+        {"id": 4, "fullText": "коротко"},
+    ]
+    p = _parser_with_pages([page])
+    got = list(p.fetch(limit=10, query="repositories.id:1298"))
+    assert [w["id"] for w in got] == [1, 3]
+
+
+def test_fetch_position_points_at_own_page():
+    # Токен обязан указывать на страницу, откуда пришла статья: пачка может
+    # прерваться на середине, и следующий прогон перечитает её целиком
+    pages = [[{"id": 1, "fullText": LONG}], [{"id": 2, "fullText": LONG + "два"}]]
+    p = _parser_with_pages(pages)
+    got = list(p.fetch(limit=10, query="repositories.id:1298"))
+    assert [w["resume_token"] for w in got] == ["1298:0", "1298:100"]
+
+
+def test_fetch_walks_archives_and_resumes():
+    p = _parser_with_pages([[], []])
+    list(p.fetch(limit=10, query="(repositories.id:1298 OR repositories.id:949)",
+                 resume_token="1298:300"))
+    # Начали с архива из токена и его смещения, пустой архив — переход к следующему
+    assert p.calls == [("1298", 300), ("949", 0)]
+
+
+def test_fetch_ignores_token_of_unknown_archive():
+    p = _parser_with_pages([[]])
+    list(p.fetch(limit=10, query="repositories.id:1298", resume_token="99999:500"))
+    assert p.calls == [("1298", 0)]
+
+
+def test_fetch_filters_years_on_our_side():
+    # Годы API не фильтрует, поэтому отсекаем сами — и только если заданы
+    page = [
+        {"id": 1, "fullText": LONG, "yearPublished": 2004},
+        {"id": 2, "fullText": LONG + "два", "yearPublished": 2015},
+        {"id": 3, "fullText": LONG + "три", "yearPublished": 2030},
+    ]
+    p = _parser_with_pages([list(page)])
+    got = list(p.fetch(limit=10, query="repositories.id:1298", year_from=2010, year_to=2026))
+    assert [w["id"] for w in got] == [2]
+
+    p2 = _parser_with_pages([list(page)])
+    got2 = list(p2.fetch(limit=10, query="repositories.id:1298"))
+    assert [w["id"] for w in got2] == [1, 2, 3]
+
+
+def test_min_chars_threshold_is_meaningful():
+    assert MIN_CHARS >= 1000
+
+
+def test_proxy_choice(monkeypatch):
+    # CORE не отвечает на ключ с российских адресов — по умолчанию идём через
+    # sing-box, но вне compose-сети прокси отключают пустым значением
+    monkeypatch.delenv("CORE_PROXY_URL", raising=False)
+    assert COREParser._proxy(None) == DEFAULT_PROXY
+    monkeypatch.setenv("CORE_PROXY_URL", "socks5://иной:1080")
+    assert COREParser._proxy(None) == "socks5://иной:1080"
+    assert COREParser._proxy("") == ""          # явное «без прокси» сильнее окружения

scripts/parsers/wikipedia_ru.py

@@ -0,0 +1,199 @@
+"""Парсер русской Википедии из дампа Wikimedia.
+
+Зачем в корпусе: студенты копируют из Википедии чаще, чем из научных статей, а
+по объёму связного русского текста ей нет альтернативы среди доступного —
+КиберЛенинка блокирует выкачку, eLIBRARY требует договора.
+
+Отличие от остальных парсеров: `fetch` возвращает **генератор**, а не список.
+Дамп — 5.6 ГБ и около 2 млн статей, держать их в памяти нельзя, поэтому
+`run_parser` читает результат лениво и пишет пачками (см. bulk_writer.py).
+
+Используется **multistream**-вариант дампа: он состоит из независимых bz2-блоков
+по 100 статей, и к нему прилагается индекс со смещениями. Это принципиально —
+обычный дамп читается только с начала, поэтому каждый следующий прогон
+перечитывал всё уже залитое: на 20 тысячах статей это стоило 6 минут из 25
+доступных, а на 100 тысячах съело бы весь бюджет и заливка встала бы совсем.
+С multistream позиция продолжения — байтовое смещение, и прогон стартует
+мгновенно.
+
+Файлы качаются заранее и кладутся туда, где их видит воркер:
+    B=https://dumps.wikimedia.org/ruwiki/latest
+    UA="AcademicHelper/1.0 (https://academic.jze9.ru; noreply@jze9.ru)"
+    curl -L -C - --retry 100 -A "$UA" -o scripts/parsers/ruwiki-multistream.xml.bz2 \\
+      $B/ruwiki-latest-pages-articles-multistream.xml.bz2
+
+Читать дамп прямо из сети не выйдет: Wikimedia обрывает долгие соединения
+(проверено — обрыв на 32 МБ из 5.9 ГБ).
+"""
+
+import bz2
+import logging
+import os
+import re
+from collections.abc import Iterator
+from typing import Any
+
+from base import BaseParser, ProgressCallback
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_DUMP = "/parsers/ruwiki-multistream.xml.bz2"
+
+PAGE_RE = re.compile(r"<page>(.*?)</page>", re.DOTALL)
+TITLE_RE = re.compile(r"<title>(.*?)</title>", re.DOTALL)
+ID_RE = re.compile(r"<id>(\d+)</id>")
+NS_RE = re.compile(r"<ns>(\d+)</ns>")
+TEXT_RE = re.compile(r"<text[^>]*>(.*?)</text>", re.DOTALL)
+REDIRECT_RE = re.compile(r"<redirect ")
+
+# Разметку чистим регулярками: для отпечатков нужен связный текст, а не точное
+# восстановление вёрстки — полноценный парсер вики-разметки тут неоправдан
+TEMPLATE_RE = re.compile(r"\{\{[^{}]*\}\}")
+CLEAN_RULES = [
+    (re.compile(r"\[\[[^\]|]*\|"), ""),                  # [[ссылка|текст → текст
+    (re.compile(r"\[\[|\]\]"), ""),
+    (re.compile(r"<ref[^>]*>.*?</ref>", re.DOTALL), " "),
+    (re.compile(r"<[^>]+>"), " "),
+    (re.compile(r"^[*#:;|!].*$", re.MULTILINE), " "),    # списки и таблицы
+    (re.compile(r"^=+.*?=+$", re.MULTILINE), " "),       # == заголовки разделов ==
+    (re.compile(r"'{2,}"), ""),
+    (re.compile(r"&[a-z]+;"), " "),
+    (re.compile(r"[ \t]+"), " "),
+    (re.compile(r"\n{2,}"), "\n"),
+]
+
+
+def clean_wikitext(raw: str) -> str:
+    """Убрать вики-разметку, оставив читаемый текст статьи."""
+    text = raw
+    for _ in range(3):          # шаблоны бывают вложенными
+        text = TEMPLATE_RE.sub(" ", text)
+    for rx, repl in CLEAN_RULES:
+        text = rx.sub(repl, text)
+    return text.strip()
+
+
+class WikipediaRuParser(BaseParser):
+    """Русская Википедия из локального дампа. Отдаёт статьи потоком."""
+
+    source_name = "wikipedia_ru"
+    # Признак для run_parser: результат читается лениво и пишется пачками,
+    # а не собирается в список и не идёт через add_document по одному
+    bulk = True
+
+    def fetch(  # type: ignore[override]
+        self,
+        limit: int = 1000,
+        min_chars: int = 2000,
+        dump_path: str | None = None,
+        start_offset: int = 0,
+        progress_cb: ProgressCallback | None = None,
+        **_ignored: Any,
+    ) -> Iterator[dict[str, Any]]:
+        """Статьи основного пространства имён из multistream-дампа.
+
+        Args:
+            limit: сколько статей отдать
+            min_chars: минимальная длина текста — заготовки в корпусе бесполезны
+            dump_path: путь к дампу (по умолчанию /parsers/ruwiki-multistream.xml.bz2)
+            start_offset: байтовое смещение в файле, с которого продолжать.
+                Именно смещение, а не номер статьи: перечитывание дампа с начала
+                росло линейно и на сотне тысяч статей съедало весь бюджет прогона
+            progress_cb: см. base.ProgressCallback
+        """
+        path = dump_path or os.environ.get("WIKIPEDIA_DUMP_PATH") or DEFAULT_DUMP
+        if not os.path.exists(path):
+            raise FileNotFoundError(
+                f"дамп Википедии не найден: {path} — скачайте его (см. модуль) "
+                f"или укажите WIKIPEDIA_DUMP_PATH"
+            )
+
+        given = 0
+        buf = ""
+
+        with open(path, "rb") as fh:
+            fh.seek(start_offset)
+            # Смещение блока, из которого пришли уже отданные статьи: его и
+            # сохраняем как позицию продолжения, чтобы ничего не потерять
+            block_offset = start_offset
+            decomp = bz2.BZ2Decompressor()
+
+            while given < limit:
+                part = fh.read(4 * 1024 * 1024)
+                if not part:
+                    break
+
+                # В multistream-дампе потоки идут подряд: закончился один —
+                # начинаем следующий с того места, где предыдущий остановился
+                while part:
+                    try:
+                        raw = decomp.decompress(part)
+                    except (OSError, EOFError):
+                        return
+                    if raw:
+                        buf += raw.decode("utf-8", errors="replace")
+
+                    if not decomp.eof:
+                        break
+                    part = decomp.unused_data
+                    decomp = bz2.BZ2Decompressor()
+
+                while given < limit:
+                    m = PAGE_RE.search(buf)
+                    if not m:
+                        break
+                    page, buf = m.group(1), buf[m.end():]
+
+                    doc = self._page_to_doc(page, min_chars)
+                    if doc is None:
+                        continue
+
+                    given += 1
+                    doc["dump_offset"] = block_offset
+                    yield doc
+
+                    if progress_cb and not progress_cb(given):
+                        logger.info("Википедия: выборка остановлена по запросу (%d)", given)
+                        return
+
+                # Всё разобранное отдано — следующая позиция продолжения здесь
+                block_offset = fh.tell() - len(buf.encode("utf-8", errors="ignore")) // 4
+
+                if len(buf) > 20 * 1024 * 1024:     # страховка от разбухания
+                    buf = buf[-1024 * 1024:]
+
+    def _page_to_doc(self, page: str, min_chars: int) -> dict[str, Any] | None:
+        """Разобрать <page> в документ; None — страница нам не подходит."""
+        if REDIRECT_RE.search(page):
+            return None
+        ns = NS_RE.search(page)
+        if not ns or ns.group(1) != "0":         # только статьи
+            return None
+
+        tm, im, xm = TITLE_RE.search(page), ID_RE.search(page), TEXT_RE.search(page)
+        if not (tm and im and xm):
+            return None
+
+        text = clean_wikitext(xm.group(1))
+        if len(text) < min_chars:
+            return None
+
+        return {"pageid": im.group(1), "title": tm.group(1), "text": text}
+
+    def transform(self, raw: dict[str, Any]) -> dict[str, Any]:
+        """Привести статью к унифицированному формату документов корпуса."""
+        pid = raw.get("pageid")
+        if not pid:
+            return {}
+        return {
+            "source": self.source_name,
+            "ext_id": f"wikipedia_ru:{pid}",
+            "title": raw.get("title", ""),
+            "authors": [],
+            "year": None,
+            "lang": "ru",
+            "url": f"https://ru.wikipedia.org/?curid={pid}",
+            "abstract": (raw.get("text") or "")[:2000],
+            "text": raw.get("text", ""),
+            "dump_offset": raw.get("dump_offset"),
+        }

services/api/alembic/versions/006_parse_run_started_at.py

@@ -0,0 +1,31 @@
+"""Отдельная отметка старта выполнения прогона парсинга.
+
+Revision ID: 006
+Revises: 005
+Create Date: 2026-08-28
+
+`started_at` пишется в момент СОЗДАНИЯ строки, то есть постановки в очередь.
+При массовом запуске очередь разбирается часами, и «длительность» прогона по
+двум таймстампам показывала 2.8 часа там, где сам парсинг занял 50 секунд —
+для отладки это дезинформация. Момент, когда воркер реально взял задачу,
+пишем отдельно; разница со `started_at` — это ожидание в очереди.
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "006"
+down_revision = "005"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # Для уже прошедших прогонов остаётся NULL: подставлять им started_at
+    # значило бы выдать время ожидания за время работы.
+    op.add_column("parse_runs", sa.Column("run_started_at", sa.DateTime(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("parse_runs", "run_started_at")

services/api/alembic/versions/007_parse_source_resume.py

@@ -0,0 +1,29 @@
+"""Позиция продолжения массовой заливки в источнике.
+
+Revision ID: 007
+Revises: 006
+Create Date: 2026-09-05
+
+Массовые источники (дамп Википедии, бакет PMC) заливаются частями: за один
+прогон берётся столько статей, сколько влезает в бюджет времени таска. Чтобы
+следующий прогон продолжал с того же места, а не перечитывал залитое заново,
+позиция сохраняется прямо в источнике: для Википедии это номер статьи в дампе,
+для PMC — токен страницы бакета.
+"""
+
+import sqlalchemy as sa
+
+from alembic import op
+
+revision = "007"
+down_revision = "006"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("parse_sources", sa.Column("resume_token", sa.Text(), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("parse_sources", "resume_token")

services/api/app/api/admin.py

@@ -50,8 +50,10 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/admin", tags=["admin"], dependencies=[Depends(get_admin_user)])
 
-# Типы источников, для которых в worker-indexer есть парсер (index.run_parser)
-SOURCE_TYPES = ("openalex", "cyberleninka", "arxiv", "pmc")
+# Типы источников, для которых в worker-indexer есть парсер (index.run_parser).
+# wikipedia_ru и pmc_bulk — массовые: читают дамп/бакет потоком и пишут пачками,
+# продолжая с сохранённой позиции (parse_sources.resume_token)
+SOURCE_TYPES = ("openalex", "cyberleninka", "arxiv", "pmc", "wikipedia_ru", "pmc_bulk")
 # Прогон в этих статусах ещё может двигаться — повторно запускать источник нельзя
 RUN_ACTIVE_STATUSES = ("queued", "running")
 
@@ -784,6 +786,20 @@ async def upload_documents(files: list[UploadFile]) -> dict:
 # ═══════════════════════════════════════════════════════════════════════════════
 # ОТЛАДКА
 # ═══════════════════════════════════════════════════════════════════════════════
+def _vector_index_stats() -> dict:
+    """Реальное наполнение векторного индекса — спросить у worker-gpu.
+
+    Колонка `documents.faiss_id` для этого не годится: пометка остаётся и когда
+    вектор в индекс не попал, и когда индекс пересоздали после смены модели
+    эмбеддингов. Отладка, показывающая покрытие L3 по ней, завышает его в разы.
+    """
+    try:
+        result = celery_app.send_task("gpu.index_stats", queue="queue.gpu")
+        return result.get(timeout=10) or {}
+    except Exception as e:
+        return {"error": str(e)[:200] or type(e).__name__}
+
+
 def _celery_snapshot() -> dict:
     """Живое состояние воркеров через Celery inspect (блокирующий вызов)."""
     try:
@@ -827,8 +843,10 @@ async def debug_snapshot(db: AsyncSession = Depends(get_db)) -> dict:
     именно сейчас крутит, что копится в очередях, как наполняется корпус,
     какие прогоны идут и на чём падали последние.
     """
-    # Воркеры — блокирующий Celery inspect, в пул потоков, чтобы не вешать луп
+    # Воркеры и статистика индекса — блокирующие вызовы Celery, в пул потоков,
+    # чтобы не вешать событийный цикл
     celery_state = await run_in_threadpool(_celery_snapshot)
+    vector_stats = await run_in_threadpool(_vector_index_stats)
 
     rmq = await _rabbitmq_queues()
     queues = (
@@ -909,14 +927,39 @@ async def debug_snapshot(db: AsyncSession = Depends(get_db)) -> dict:
         )
     ).scalars().all()
 
+    # Зависшая проверка: числится в работе, но воркер давно её не трогал.
+    # Пользователь видит вечное «обрабатывается» — молча и без следов в логах,
+    # поэтому такие задачи должны быть видны в отладке (нашлись экземпляры,
+    # висевшие с мая).
+    #
+    # Возраст считает сама база: колонки в PostgreSQL — timestamptz, а модель
+    # объявляет их без зоны, и передача сюда Python-времени ломается на
+    # несовпадении (asyncpg отвергает aware-параметр, naive даёт неверный сдвиг).
+    stale_tasks = (
+        await db.execute(
+            text("""
+                SELECT public_id, type, created_at,
+                       round(extract(epoch FROM now() - coalesce(updated_at, created_at))
+                             / 3600.0, 1) AS stuck_hours
+                FROM tasks
+                WHERE status = 'processing'
+                  AND coalesce(updated_at, created_at) < now() - interval '2 hours'
+                ORDER BY created_at DESC
+                LIMIT 20
+            """)
+        )
+    ).all()
+
     return {
         "generated_at": datetime.utcnow().isoformat(timespec="seconds"),
         "celery": celery_state,
         "queues": queues,
         "corpus": {
             "documents": docs_total,
-            "documents_embedded": docs_embedded,
-            "documents_without_embedding": max(docs_total - docs_embedded, 0),
+            # Пометка в БД и реальное содержимое индекса расходятся — показываем
+            # обе величины, иначе покрытие L3 выглядит лучше, чем оно есть
+            "documents_marked_embedded": docs_embedded,
+            "vector_index": vector_stats,
             "fingerprints_estimate": int(fingerprints_est),
             "elasticsearch_documents": es_docs,
         },
@@ -938,6 +981,15 @@ async def debug_snapshot(db: AsyncSession = Depends(get_db)) -> dict:
             }
             for t in failed_tasks
         ],
+        "stale_tasks": [
+            {
+                "public_id": t.public_id,
+                "type": t.type,
+                "created_at": t.created_at,
+                "stuck_hours": float(t.stuck_hours),
+            }
+            for t in stale_tasks
+        ],
         # Ключи бэкендов задаются в .env (генерируется из Infisical) и влияют на
         # поведение воркеров — при разборе «почему не так считает» нужны первыми
         "config": {

services/api/app/models/admin.py

@@ -35,6 +35,9 @@ class ParseSource(Base):
     docs_added: Mapped[int] = mapped_column(default=0)
     # Последний (пока идёт — текущий) прогон, см. ParseRun
     last_run_id: Mapped[int | None] = mapped_column(nullable=True)
+    # Позиция продолжения для массовых источников: номер статьи в дампе
+    # Википедии или токен страницы бакета PMC
+    resume_token: Mapped[str | None] = mapped_column(Text, nullable=True)
     created_at: Mapped[datetime] = mapped_column(server_default=func.now())
 
     def __repr__(self) -> str:
@@ -75,7 +78,10 @@ class ParseRun(Base):
     error: Mapped[str | None] = mapped_column(Text, nullable=True)
     # [{"ts": ISO8601, "level": "info|warning|error", "msg": str}]
     log: Mapped[list | None] = mapped_column(JSON, default=list)
+    # Постановка в очередь (строку создаёт API) и реальный старт выполнения:
+    # между ними при массовом запуске проходят часы, мешать их нельзя
     started_at: Mapped[datetime] = mapped_column(server_default=func.now(), index=True)
+    run_started_at: Mapped[datetime | None] = mapped_column(nullable=True)
     # Последний признак жизни: по нему видно зависший прогон (running, но тишина)
     heartbeat_at: Mapped[datetime | None] = mapped_column(nullable=True)
     finished_at: Mapped[datetime | None] = mapped_column(nullable=True)

services/api/app/schemas/admin.py

@@ -80,7 +80,9 @@ class ParseRunResponse(BaseModel):
     failed: int
     cancel_requested: bool = False
     error: str | None = None
+    # started_at — постановка в очередь, run_started_at — реальный старт работы
     started_at: datetime
+    run_started_at: datetime | None = None
     heartbeat_at: datetime | None = None
     finished_at: datetime | None = None
 
@@ -91,6 +93,26 @@ class ParseRunResponse(BaseModel):
     def percent(self) -> float:
         return run_percent(self.status, self.stage, self.target, self.fetched, self.processed)
 
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def queued_s(self) -> float | None:
+        """Сколько прогон ждал своей очереди, сек."""
+        if self.run_started_at is None:
+            return None
+        return round((self.run_started_at - self.started_at).total_seconds(), 1)
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def duration_s(self) -> float | None:
+        """Сколько прогон реально работал, сек (None — ещё идёт или не начинался).
+
+        Прогоны до появления run_started_at (миграция 006) остаются без
+        длительности: у них известен только момент постановки в очередь.
+        """
+        if self.run_started_at is None or self.finished_at is None:
+            return None
+        return round((self.finished_at - self.run_started_at).total_seconds(), 1)
+
 
 class ParseRunDetail(ParseRunResponse):
     log: list[dict[str, Any]] = Field(default_factory=list)
@@ -98,7 +120,9 @@ class ParseRunDetail(ParseRunResponse):
 
 # ─── Источники парсинга ───────────────────────────────────────────────────────
 class ParseSourceCreate(BaseModel):
-    source_type: str = Field(description="openalex / cyberleninka / arxiv / pmc")
+    source_type: str = Field(
+        description="openalex / cyberleninka / arxiv / pmc / wikipedia_ru / pmc_bulk"
+    )
     name: str = Field(min_length=1, max_length=255)
     query: str | None = None
     lang: str | None = None
@@ -142,7 +166,9 @@ class ParseSourceResponse(BaseModel):
 class ParseSourceBulkCreate(BaseModel):
     """Пакетное добавление: один тип/лимит, много запросов (по строке на тему)."""
 
-    source_type: str = Field(description="openalex / cyberleninka / arxiv / pmc")
+    source_type: str = Field(
+        description="openalex / cyberleninka / arxiv / pmc / wikipedia_ru / pmc_bulk"
+    )
     queries: list[str] = Field(min_length=1, max_length=500)
     name_prefix: str = ""
     lang: str | None = None

services/api/tests/test_progress.py

@@ -1,6 +1,9 @@
-"""Юнит-тесты шкалы загрузки источников (app.core.progress) — чистая логика."""
+"""Юнит-тесты шкалы загрузки и таймингов прогонов — чистая логика, без БД."""
+
+from datetime import datetime
 
 from app.core.progress import run_percent
+from app.schemas.admin import ParseRunResponse
 
 
 def test_queued_run_shows_nothing_done():
@@ -39,3 +42,45 @@ def test_finished_runs_are_always_full():
     """Шкала показывает «работа окончена», исход виден по статусу рядом."""
     for status in ("done", "partial", "error", "cancelled"):
         assert run_percent(status, "finished", target=100, fetched=3, processed=1) == 100.0
+
+
+# ─── Тайминги прогона в схеме ответа ─────────────────────────────────────────
+# Регрессия, ради которой они и разделены: в отладке «длительность прогона»
+# показывала время ожидания в очереди (часы) вместо времени работы (секунды).
+
+
+def _run(**over) -> ParseRunResponse:
+    base = {
+        "id": 1, "source_id": 1, "status": "done", "stage": "finished", "target": 100,
+        "fetched": 100, "processed": 100, "added": 10, "duplicates": 90,
+        "skipped": 0, "failed": 0,
+        "started_at": datetime(2026, 8, 27, 12, 0, 0),
+        "run_started_at": datetime(2026, 8, 27, 14, 0, 0),
+        "finished_at": datetime(2026, 8, 27, 14, 0, 50),
+    }
+    base.update(over)
+    return ParseRunResponse(**base)
+
+
+def test_queued_and_duration_are_measured_separately():
+    r = _run()
+    assert r.queued_s == 7200.0  # два часа в очереди
+    assert r.duration_s == 50.0  # полминуты работы
+
+
+def test_no_durations_until_worker_picked_run_up():
+    r = _run(status="queued", stage="queued", run_started_at=None, finished_at=None)
+    assert r.queued_s is None
+    assert r.duration_s is None
+
+
+def test_running_run_has_wait_but_no_duration_yet():
+    r = _run(status="running", stage="index", finished_at=None)
+    assert r.queued_s == 7200.0
+    assert r.duration_s is None
+
+
+def test_legacy_runs_report_no_duration_instead_of_queue_time():
+    """Прогоны до миграции 006: длительности нет — но и вранья тоже."""
+    r = _run(run_started_at=None)
+    assert r.duration_s is None

services/frontend/src/pages/admin/Debug.tsx

@@ -1,18 +1,21 @@
 import React from 'react';
 import { useQuery } from '@tanstack/react-query';
 import {
-  Activity, AlertTriangle, Cpu, Database, Layers, RefreshCw, Settings2, ListTree,
+  Activity, AlertTriangle, CheckCircle2, Cpu, Database, Layers, RefreshCw,
+  Server, Settings2, ListTree, XCircle,
 } from 'lucide-react';
 import { adminApi } from '../../api/client';
 import { ProgressBar } from '../../components/ProgressBar';
 
+interface Health { name: string; ok: boolean; detail?: string }
 interface ActiveTask { name: string; id: string; args: string; started_ago_s: number | null }
 interface Worker { name: string; concurrency: number | null; reserved: number; active: ActiveTask[] }
 interface Run {
   id: number; source_id: number; status: string; stage: string; target: number;
   fetched: number; processed: number; added: number; duplicates: number;
   skipped: number; failed: number; error: string | null; percent: number;
-  started_at: string; heartbeat_at: string | null;
+  started_at: string; run_started_at: string | null; heartbeat_at: string | null;
+  queued_s: number | null; duration_s: number | null;
 }
 
 interface DebugData {
@@ -20,7 +23,8 @@ interface DebugData {
   celery: { workers: Worker[]; error?: string };
   queues: Record<string, { messages: number; unacked: number; consumers: number }> | { error: string };
   corpus: {
-    documents: number; documents_embedded: number; documents_without_embedding: number;
+    documents: number; documents_marked_embedded: number;
+    vector_index: { backend?: string; vectors?: number; dim?: number; embed_model?: string; error?: string };
     fingerprints_estimate: number; elasticsearch_documents: number | null;
   };
   sources: {
@@ -42,24 +46,48 @@ function fmtNum(n: number | null | undefined): string {
   return n == null ? '—' : n.toLocaleString('ru-RU');
 }
 
+/** Сколько идущий прогон уже работает — по нему видно застрявший. */
+function runningFor(run: Run): string {
+  if (!run.run_started_at) return 'ещё не начат';
+  const sec = Math.max(0, (Date.now() - new Date(run.run_started_at + 'Z').getTime()) / 1000);
+  return sec < 90 ? `${Math.round(sec)}с` : `${Math.round(sec / 60)} мин`;
+}
+
 export function Debug() {
   const { data, isFetching, error } = useQuery({
     queryKey: ['admin-debug'],
     queryFn: () => adminApi.debug().then((r) => r.data as DebugData),
     refetchInterval: 5000,
   });
+  // Отдельным запросом: когда отваливается инфраструктура (брокер, Ollama),
+  // отладка должна первой показывать ЧТО именно недоступно, а не только следствия
+  const { data: health } = useQuery({
+    queryKey: ['admin-health'],
+    queryFn: () => adminApi.health().then((r) => r.data as Health[]),
+    refetchInterval: 10000,
+  });
 
-  if (error) {
-    return <div className="text-red-600 text-sm">Не удалось получить срез состояния: {String(error)}</div>;
-  }
-  if (!data) {
-    return <div className="text-gray-400 text-sm">Сбор данных…</div>;
+  if (error || !data) {
+    return (
+      <div className="space-y-4">
+        {error
+          ? <div className="text-red-600 text-sm">Не удалось получить срез состояния: {String(error)}</div>
+          : <div className="text-gray-400 text-sm">Сбор данных…</div>}
+        <HealthCard health={health} />
+      </div>
+    );
   }
 
   const queuesErr = 'error' in data.queues ? (data.queues as { error: string }).error : null;
   const queues = queuesErr ? {} : (data.queues as Record<string, { messages: number; unacked: number; consumers: number }>);
-  const embedPercent = data.corpus.documents
-    ? (data.corpus.documents_embedded / data.corpus.documents) * 100
+  // Покрытие L3 считаем по РЕАЛЬНОМУ содержимому индекса: пометка faiss_id в БД
+  // остаётся и когда вектор туда не попал, и завышает картину в разы
+  const vectors = data.corpus.vector_index?.vectors ?? null;
+  const embedPercent = data.corpus.documents && vectors != null
+    ? (vectors / data.corpus.documents) * 100
+    : 0;
+  const staleMarks = vectors != null
+    ? Math.max(0, data.corpus.documents_marked_embedded - vectors)
     : 0;
 
   return (
@@ -72,6 +100,8 @@ export function Debug() {
         <span className="text-xs text-gray-400">срез от {new Date(data.generated_at).toLocaleTimeString('ru-RU')}</span>
       </div>
 
+      <HealthCard health={health} />
+
       {/* Активные прогоны заливки */}
       <Card icon={Layers} title={`Заливка источников — активных прогонов: ${data.sources.active_runs.length}`}>
         {data.sources.stale_run_ids.length > 0 && (
@@ -87,8 +117,9 @@ export function Debug() {
           <div className="space-y-3">
             {data.sources.active_runs.map((r) => (
               <div key={r.id} className="flex items-center gap-4">
-                <div className="w-40 shrink-0 text-sm text-gray-600 truncate">
+                <div className="w-52 shrink-0 text-sm text-gray-600 truncate">
                   #{r.id} · источник {r.source_id}
+                  <span className="text-gray-400"> · {runningFor(r)}</span>
                 </div>
                 <ProgressBar
                   percent={r.percent}
@@ -167,15 +198,32 @@ export function Debug() {
       <Card icon={Database} title="Корпус сравнения">
         <div className="grid grid-cols-2 lg:grid-cols-4 gap-4 mb-4">
           <Metric label="Документов" value={fmtNum(data.corpus.documents)} />
-          <Metric label="С эмбеддингом" value={fmtNum(data.corpus.documents_embedded)} />
+          <Metric label="Векторов в индексе" value={fmtNum(vectors)} />
           <Metric label="Отпечатков (оценка)" value={fmtNum(data.corpus.fingerprints_estimate)} />
           <Metric label="В Elasticsearch" value={fmtNum(data.corpus.elasticsearch_documents)} />
         </div>
+        {data.corpus.vector_index?.error && (
+          <p className="text-xs text-red-600 mb-2">
+            индекс недоступен: {data.corpus.vector_index.error}
+          </p>
+        )}
         <ProgressBar
           percent={embedPercent}
-          status={data.corpus.documents_without_embedding > 0 ? 'partial' : 'done'}
-          label={`покрытие эмбеддингами (L3): без вектора ${fmtNum(data.corpus.documents_without_embedding)} документов`}
+          status={embedPercent >= 99 ? 'done' : 'partial'}
+          label={`покрытие L3 (реально в индексе ${data.corpus.vector_index?.backend || '—'}): ` +
+            `без вектора ${fmtNum(Math.max(0, data.corpus.documents - (vectors ?? 0)))} документов`}
         />
+        {staleMarks > 0 && (
+          <div className="mt-3 flex items-start gap-2 text-sm text-amber-700 bg-amber-50 border border-amber-100 rounded-lg p-3">
+            <AlertTriangle className="w-4 h-4 mt-0.5 shrink-0" />
+            <span>
+              У {fmtNum(staleMarks)} документов в базе стоит отметка faiss_id, но вектора в индексе нет —
+              обычно это след пересоздания индекса после смены модели эмбеддингов.
+              Такие документы не участвуют в семантическом поиске и не будут пересчитаны,
+              пока отметку не сбросить: <code>scripts/ops/faiss_reconcile.py</code>.
+            </span>
+          </div>
+        )}
       </Card>
 
       {/* Проблемные прогоны */}
@@ -189,6 +237,7 @@ export function Debug() {
                 <span className={r.status === 'error' ? 'text-red-600' : 'text-amber-600'}>{r.status}</span>
                 <span className="text-gray-500">
                   получено {r.fetched}/{r.target}, добавлено {r.added}, ошибок {r.failed}
+                  {r.duration_s != null && ` · работал ${Math.round(r.duration_s)}с`}
                 </span>
                 {r.error && <span className="w-full text-xs font-mono text-red-600 break-all">{r.error}</span>}
               </div>
@@ -234,6 +283,31 @@ export function Debug() {
   );
 }
 
+/** Что из инфраструктуры доступно прямо сейчас — первый вопрос при разборе аварии. */
+function HealthCard({ health }: { health?: Health[] }) {
+  return (
+    <Card icon={Server} title="Инфраструктура">
+      {health?.length ? (
+        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-x-6 gap-y-1">
+          {health.map((h) => (
+            <div key={h.name} className="flex items-center justify-between gap-3 py-1 border-b border-gray-50">
+              <span className="flex items-center gap-2 text-sm text-gray-700">
+                {h.ok
+                  ? <CheckCircle2 className="w-4 h-4 text-emerald-500 shrink-0" />
+                  : <XCircle className="w-4 h-4 text-red-500 shrink-0" />}
+                {h.name}
+              </span>
+              <span className={`text-xs truncate ${h.ok ? 'text-gray-400' : 'text-red-500'}`} title={h.detail}>
+                {h.detail || (h.ok ? 'OK' : 'недоступен')}
+              </span>
+            </div>
+          ))}
+        </div>
+      ) : <p className="text-sm text-gray-400">Опрос сервисов…</p>}
+    </Card>
+  );
+}
+
 function Card({ icon: Icon, title, children }: { icon: React.ElementType; title: string; children: React.ReactNode }) {
   return (
     <div className="bg-white rounded-xl border border-gray-100 p-5">

services/frontend/src/pages/admin/Sources.tsx

@@ -13,8 +13,9 @@ interface Run {
   target: number; fetched: number; processed: number;
   added: number; duplicates: number; skipped: number; failed: number;
   cancel_requested: boolean; error: string | null;
-  started_at: string; heartbeat_at: string | null; finished_at: string | null;
-  percent: number;
+  started_at: string; run_started_at: string | null;
+  heartbeat_at: string | null; finished_at: string | null;
+  percent: number; queued_s: number | null; duration_s: number | null;
 }
 
 interface LogEntry { ts: string; elapsed: number; level: string; msg: string }
@@ -31,7 +32,11 @@ const SOURCE_TYPES = [
   { value: 'openalex', label: 'OpenAlex' },
   { value: 'cyberleninka', label: 'КиберЛенинка' },
   { value: 'arxiv', label: 'arXiv' },
-  { value: 'pmc', label: 'PubMed Central' },
+  { value: 'pmc', label: 'PubMed Central (по теме)' },
+  // Массовые: читают дамп/бакет потоком и продолжают с места остановки,
+  // поэтому запускаются повторно до исчерпания источника
+  { value: 'wikipedia_ru', label: 'Википедия ru (дамп, массово)' },
+  { value: 'pmc_bulk', label: 'PubMed Central (бакет, массово)' },
 ];
 
 const STATUS_COLORS: Record<string, string> = {
@@ -360,6 +365,14 @@ export function Sources() {
   );
 }
 
+/** Секунды → «45с» / «12 мин» / «2 ч 5 мин»: в отладке важен порядок, не точность. */
+function fmtDuration(seconds: number): string {
+  if (seconds < 90) return `${Math.round(seconds)}с`;
+  const min = Math.round(seconds / 60);
+  if (min < 90) return `${min} мин`;
+  return `${Math.floor(min / 60)} ч ${min % 60} мин`;
+}
+
 const LOG_COLORS: Record<string, string> = {
   error: 'text-red-600',
   warning: 'text-amber-600',
@@ -389,7 +402,9 @@ function RunLog({ runId, live }: { runId?: number; live: boolean }) {
         <Chip label="дублей" value={String(data.duplicates)} />
         {data.skipped > 0 && <Chip label="без метаданных" value={String(data.skipped)} />}
         {data.failed > 0 && <Chip label="ошибок" value={String(data.failed)} />}
-        <Chip label="начат" value={new Date(data.started_at).toLocaleString('ru-RU')} />
+        <Chip label="поставлен в очередь" value={new Date(data.started_at).toLocaleString('ru-RU')} />
+        {data.queued_s != null && <Chip label="ждал очереди" value={fmtDuration(data.queued_s)} />}
+        {data.duration_s != null && <Chip label="работал" value={fmtDuration(data.duration_s)} />}
         {data.finished_at && <Chip label="завершён" value={new Date(data.finished_at).toLocaleString('ru-RU')} />}
       </div>
 

services/worker-gpu/Dockerfile

@@ -28,4 +28,11 @@ COPY . .
 # Директория для FAISS индекса (монтируется как volume)
 RUN mkdir -p /data/index
 
+# -c 1 обязателен, пока VECTOR_BACKEND=faiss: индекс — синглтон в памяти процесса
+# (app/faiss_manager.py). При -c N Celery форкает N процессов, у каждого своя копия
+# индекса, и save() каждого затирает чужие векторы в общем файле — эмбеддинги
+# теряются молча. Параллельность тут всё равно не нужна: Ollama занимает все ядра
+# сервера обработкой одного запроса (замер: 2.29 req/s при конкурентности 1 против
+# 2.48 при 16). Поднимать -c имеет смысл только вместе с VECTOR_BACKEND=qdrant,
+# который допускает конкурентную запись.
 CMD ["celery", "-A", "app.celery_app", "worker", "-Q", "queue.gpu", "-c", "1", "-n", "gpu@%h", "--loglevel=info"]

services/worker-gpu/app/celery_app.py

@@ -9,7 +9,7 @@ celery_app = Celery(
     "worker_gpu",
     broker=settings.RABBITMQ_URL,
     backend=settings.REDIS_URL,
-    include=["app.tasks.search", "app.tasks.plagiarism"],
+    include=["app.tasks.search", "app.tasks.plagiarism", "app.tasks.stats"],
 )
 
 celery_app.conf.update(

services/worker-gpu/app/tasks/stats.py

@@ -0,0 +1,39 @@
+"""Служебная задача: состояние векторного индекса для панели отладки.
+
+Индекс живёт в памяти и на диске worker-gpu, у API к нему доступа нет. Без этой
+задачи админка показывала покрытие L3 по колонке `documents.faiss_id` — а она
+врёт: пометка остаётся и тогда, когда вектор в индекс не попал (или индекс был
+пересоздан после смены модели эмбеддингов). Здесь возвращается то, что в индексе
+есть на самом деле.
+"""
+
+from typing import Any
+
+from celery.utils.log import get_task_logger
+
+from app.celery_app import celery_app
+from app.config import settings
+from app.vector_store import get_backend
+
+logger = get_task_logger(__name__)
+
+
+@celery_app.task(name="gpu.index_stats")
+def index_stats() -> dict[str, Any]:
+    """Реальное число векторов в активном бэкенде (FAISS или Qdrant)."""
+    backend = get_backend()
+    try:
+        # У FAISS индекс ленивый: без обращения ntotal вернёт 0 на холодном воркере
+        if hasattr(backend, "_ensure"):
+            backend._ensure()
+        total = backend.total_vectors()
+    except Exception as e:
+        logger.warning(f"index_stats: не удалось прочитать индекс: {e}")
+        return {"backend": settings.VECTOR_BACKEND, "error": str(e)[:200]}
+
+    return {
+        "backend": settings.VECTOR_BACKEND,
+        "vectors": total,
+        "dim": settings.EMBED_DIM,
+        "embed_model": settings.EMBED_MODEL,
+    }

services/worker-indexer/app/algorithms/winnowing.py

@@ -85,6 +85,68 @@ def winnow(text: str, k: int = 5, window: int = 4) -> set[int]:
     return fingerprint
 
 
+def winnow_ordered(text: str, k: int = 5, window: int = 4) -> list[int]:
+    """То же, что winnow, но с сохранением порядка появления отпечатков в тексте.
+
+    Нужно там, где отпечатки приходится обрезать по лимиту: множество не хранит
+    порядка, и `list(winnow(text))[:limit]` берёт произвольное подмножество —
+    у длинного документа целые куски остаются без покрытия, и списывание из них
+    не находится. Со списком в порядке текста обрезку можно делать равномерной
+    (см. sample_evenly).
+
+    Args:
+        text: Исходный текст
+        k: Размер k-граммы
+        window: Размер скользящего окна
+
+    Returns:
+        Отпечатки в порядке появления в тексте, без повторов
+    """
+    tokens = text.lower().split()
+    if len(tokens) < k:
+        return []
+
+    hashes = [hash_ngram(ng) for ng in get_ngrams(tokens, k)]
+    if not hashes:
+        return []
+
+    ordered: list[int] = []
+    seen: set[int] = set()
+    prev_min_idx = -1
+
+    for i in range(len(hashes) - window + 1):
+        window_hashes = hashes[i : i + window]
+        min_val = min(window_hashes)
+        min_idx = i + window_hashes.index(min_val)
+
+        if min_idx != prev_min_idx:
+            if min_val not in seen:
+                seen.add(min_val)
+                ordered.append(min_val)
+            prev_min_idx = min_idx
+
+    return ordered
+
+
+def sample_evenly(items: list[int], limit: int) -> list[int]:
+    """Оставить не больше limit элементов, равномерно по всей длине списка.
+
+    Берём каждый n-й элемент, а не первые limit штук: обрезка «с начала»
+    оставила бы без отпечатков весь конец документа.
+
+    Args:
+        items: Отпечатки в порядке текста (winnow_ordered)
+        limit: Максимум отпечатков; 0 или меньше — не ограничивать
+
+    Returns:
+        Подсписок длиной не больше limit, сохраняющий порядок
+    """
+    if limit <= 0 or len(items) <= limit:
+        return items
+    step = len(items) / limit
+    return [items[int(i * step)] for i in range(limit)]
+
+
 def jaccard_similarity(fp_a: set[int], fp_b: set[int]) -> float:
     """
     Коэффициент Жаккара для двух fingerprint'ов.

services/worker-indexer/app/bulk_writer.py

@@ -0,0 +1,132 @@
+"""Пакетная запись документов корпуса — путь для массовых источников.
+
+Обычный `index.add_document` пишет по одному документу через ORM: удобно для
+парсеров, отдающих сотни статей, но на миллионах это тупик. Замер на проде:
+построчная вставка отпечатков — 6.7 тыс. строк/с, COPY — 21 тыс. строк/с, а
+миллион статей это ~2 млрд отпечатков. Разница между сутками и неделями.
+
+Поэтому массовые источники (дампы Википедии, бакет PMC) идут сюда: документы
+вставляются одной командой с ON CONFLICT, отпечатки — через COPY.
+
+Elasticsearch и эмбеддинги здесь намеренно не трогаются: L1 и L2 начинают
+работать сразу, а векторы для L3 досчитываются отдельно
+(`scripts/ops/reembed_missing.py`) — иначе заливка упирается в скорость
+сервера эмбеддингов и тормозит на порядок.
+"""
+
+import contextlib
+import io
+import logging
+import time
+from typing import Any
+
+import psycopg2
+
+from app.algorithms.winnowing import sample_evenly, winnow_ordered
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+# Сколько попыток пережить обрыв соединения с базой. Массовая заливка идёт
+# часами, и разрыв сети за это время — норма, а не исключение.
+DB_RETRIES = 5
+
+
+def connect():
+    """Отдельное подключение psycopg2: COPY недоступен через ORM-сессию."""
+    return psycopg2.connect(
+        host=settings.POSTGRES_HOST,
+        port=settings.POSTGRES_PORT,
+        dbname=settings.POSTGRES_DB,
+        user=settings.POSTGRES_USER,
+        password=settings.POSTGRES_PASSWORD,
+    )
+
+
+def write_batch(conn, docs: list[dict[str, Any]], fp_limit: int) -> tuple[Any, dict[str, int]]:
+    """Записать пачку документов с отпечатками, пережив обрыв соединения.
+
+    Args:
+        conn: активное подключение psycopg2 (может быть заменено при обрыве)
+        docs: документы в унифицированном формате парсеров; нужны ext_id,
+            source, title и text — остальное необязательно
+        fp_limit: максимум отпечатков на документ
+
+    Returns:
+        (соединение, счётчики) — соединение может оказаться новым, если
+        пришлось переподключаться; счётчики: added / duplicates / fingerprints
+    """
+    if not docs:
+        return conn, {"added": 0, "duplicates": 0, "fingerprints": 0}
+
+    for attempt in range(1, DB_RETRIES + 1):
+        try:
+            return conn, _write_once(conn, docs, fp_limit)
+        except psycopg2.OperationalError as e:
+            wait = min(60, 5 * attempt)
+            logger.warning(
+                "bulk_writer: база недоступна (%s), повтор через %sс [%s/%s]",
+                str(e).strip()[:80], wait, attempt, DB_RETRIES,
+            )
+            time.sleep(wait)
+            with contextlib.suppress(Exception):
+                conn.close()
+            try:
+                conn = connect()
+            except Exception:
+                continue
+
+    raise RuntimeError(f"не удалось записать пачку после {DB_RETRIES} попыток")
+
+
+def _write_once(conn, docs: list[dict[str, Any]], fp_limit: int) -> dict[str, int]:
+    """Одна попытка записи; счётчики возвращаются только при успехе."""
+    added = duplicates = fingerprints = 0
+
+    with conn.cursor() as cur:
+        cur.executemany(
+            """INSERT INTO documents (ext_id, source, title, doi, year, lang, journal,
+                                      abstract, url, authors, indexed_at)
+               VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,'[]'::json, now())
+               ON CONFLICT (ext_id) DO NOTHING""",
+            [
+                (
+                    d["ext_id"], d["source"], (d.get("title") or "")[:1000], d.get("doi"),
+                    d.get("year"), d.get("lang"), (d.get("journal") or None),
+                    (d.get("text") or "")[:2000], d.get("url"),
+                )
+                for d in docs
+            ],
+        )
+
+        cur.execute(
+            "SELECT id, ext_id FROM documents WHERE ext_id = ANY(%s)",
+            ([d["ext_id"] for d in docs],),
+        )
+        id_by_ext = {ext: doc_id for doc_id, ext in cur.fetchall()}
+
+        buf = io.StringIO()
+        for d in docs:
+            doc_id = id_by_ext.get(d["ext_id"])
+            if doc_id is None:
+                continue
+            # Уже с отпечатками — значит документ залит прошлым прогоном
+            cur.execute("SELECT 1 FROM fingerprints WHERE doc_id = %s LIMIT 1", (doc_id,))
+            if cur.fetchone():
+                duplicates += 1
+                continue
+
+            hashes = sample_evenly(winnow_ordered(d.get("text") or ""), fp_limit)
+            if not hashes:
+                continue
+            for pos, h in enumerate(hashes):
+                buf.write(f"{doc_id}\t{h}\t{pos}\n")
+            fingerprints += len(hashes)
+            added += 1
+
+        buf.seek(0)
+        if added:
+            cur.copy_from(buf, "fingerprints", columns=("doc_id", "hash_value", "position"))
+
+    conn.commit()
+    return {"added": added, "duplicates": duplicates, "fingerprints": fingerprints}

services/worker-indexer/app/config.py

@@ -59,6 +59,12 @@ class Settings(BaseSettings):
     FULL_TEXT_MIN_CHARS: int = 500  # Минимум символов, иначе считаем извлечение неудачным
     EMBED_BATCH_SIZE: int = 64  # Размер пачки документов для диспатча эмбеддингов
 
+    # Сколько документов массового источника пишется одной транзакцией.
+    # Больше — меньше накладных расходов, но длиннее транзакция: 500 статей по
+    # 2000 отпечатков это миллион строк за раз, и на таком объёме соединение
+    # обрывалось. 150 — компромисс, проверенный на заливке Википедии.
+    BULK_WRITE_BATCH: int = 150
+
     # Бюджет времени одного прогона index.run_parser. RabbitMQ рвёт канал
     # consumer'а, не сделавшего ack за consumer_timeout (по умолчанию 1800с):
     # воркер падает, сообщение передоставляется, таск начинается заново —

services/worker-indexer/app/models/__init__.py

@@ -78,6 +78,7 @@ class ParseSource(Base):
     last_run_at: Mapped[datetime | None] = mapped_column(nullable=True)
     docs_added: Mapped[int] = mapped_column(default=0)
     last_run_id: Mapped[int | None] = mapped_column(nullable=True)
+    resume_token: Mapped[str | None] = mapped_column(Text, nullable=True)
     created_at: Mapped[datetime] = mapped_column(server_default=func.now())
 
 
@@ -101,6 +102,7 @@ class ParseRun(Base):
     error: Mapped[str | None] = mapped_column(Text, nullable=True)
     log: Mapped[list | None] = mapped_column(JSON, default=list)
     started_at: Mapped[datetime] = mapped_column(server_default=func.now())
+    run_started_at: Mapped[datetime | None] = mapped_column(nullable=True)
     heartbeat_at: Mapped[datetime | None] = mapped_column(nullable=True)
     finished_at: Mapped[datetime | None] = mapped_column(nullable=True)
 

services/worker-indexer/app/tasks/index.py

@@ -1,5 +1,6 @@
 """Celery задачи индексации документов и проверки плагиата (уровни 1-2)."""
 
+import contextlib
 import io
 from datetime import UTC, datetime
 from pathlib import Path
@@ -10,7 +11,7 @@ from sqlalchemy import func, select, update
 from sqlalchemy.exc import IntegrityError
 
 from app.algorithms.minhash import add_to_lsh, find_similar
-from app.algorithms.winnowing import winnow
+from app.algorithms.winnowing import sample_evenly, winnow, winnow_ordered
 from app.celery_app import celery_app
 from app.config import settings
 from app.db import db_session, get_minio, refund_plagiarism_quota, update_task_status
@@ -284,8 +285,9 @@ def add_document(doc_data: dict[str, Any], dispatch_embed: bool = True) -> dict[
         # Вычислить fingerprints
         text = doc_data.get("full_text") or doc_data.get("abstract", "") or ""
         if text:
-            fp = winnow(text)
-            fingerprints_to_add = list(fp)[: settings.MAX_FINGERPRINTS_PER_DOC]
+            fingerprints_to_add = sample_evenly(
+                winnow_ordered(text), settings.MAX_FINGERPRINTS_PER_DOC
+            )
             for i, hash_val in enumerate(fingerprints_to_add):
                 session.add(Fingerprint(doc_id=doc_id, hash_value=hash_val, position=i))
 
@@ -347,6 +349,53 @@ def add_document(doc_data: dict[str, Any], dispatch_embed: bool = True) -> dict[
     return {"status": "indexed", "doc_id": doc_id}
 
 
+def store_full_text(doc_id: int, text: str) -> dict[str, Any]:
+    """Сохранить полный текст документа и переиндексировать его по нему.
+
+    Общая часть для всех путей получения полного текста: скачанный PDF
+    (enrich_full_text) и текст, пришедший прямо из API источника (бэкфилл PMC —
+    scripts/ops/). Провизорные fingerprints, посчитанные по аннотации,
+    заменяются на посчитанные по полному тексту — ради этого всё и делается:
+    L1 начинает видеть тело статьи, а не только её краткое описание.
+
+    Args:
+        doc_id: документ в PostgreSQL
+        text: полный текст статьи
+
+    Returns:
+        dict со статусом, объёмом текста и числом отпечатков
+    """
+    from sqlalchemy import delete
+
+    from app.models import Document, Fingerprint
+
+    minio = get_minio()
+    key = f"corpus/{doc_id}.txt"
+    data = text.encode("utf-8")
+    minio.put_object(
+        settings.MINIO_BUCKET_DOCS, key, io.BytesIO(data), length=len(data),
+        content_type="text/plain; charset=utf-8",
+    )
+
+    hashes = sample_evenly(winnow_ordered(text), settings.MAX_FINGERPRINTS_PER_DOC)
+
+    with db_session() as session:
+        doc = session.get(Document, doc_id)
+        if doc is None:
+            return {"status": "doc_gone", "doc_id": doc_id}
+        doc.minio_key = key
+        session.execute(delete(Fingerprint).where(Fingerprint.doc_id == doc_id))
+        for i, hash_val in enumerate(hashes):
+            session.add(Fingerprint(doc_id=doc_id, hash_value=hash_val, position=i))
+        session.commit()
+
+    # MinHash LSH (L2) тоже должен считаться по полному тексту
+    add_to_lsh(f"doc:{doc_id}", text)
+
+    logger.info(f"store_full_text: doc={doc_id} {len(text)} симв., fingerprints={len(hashes)}")
+    return {"status": "ok", "doc_id": doc_id, "chars": len(text), "fingerprints": len(hashes)}
+
+
 @celery_app.task(
     name="index.enrich_full_text",
     bind=True,
@@ -366,51 +415,17 @@ def enrich_full_text(self, doc_id: int, url: str) -> dict[str, Any]:
     Недоступный/не-PDF источник — не ошибка: возвращаем no_fulltext.
     """
     from app.fulltext import fetch_full_text
-    from app.models import Document, Fingerprint
 
     text = fetch_full_text(url)
     if not text:
         return {"status": "no_fulltext", "doc_id": doc_id}
 
-    # Сохранить полный текст в MinIO
     try:
-        minio = get_minio()
-        key = f"corpus/{doc_id}.txt"
-        data = text.encode("utf-8")
-        minio.put_object(
-            settings.MINIO_BUCKET_DOCS, key, io.BytesIO(data), length=len(data),
-            content_type="text/plain; charset=utf-8",
-        )
+        return store_full_text(doc_id, text)
     except Exception as exc:
-        logger.error(f"enrich_full_text: не удалось сохранить текст в MinIO для {doc_id}: {exc}")
+        logger.error(f"enrich_full_text: не удалось сохранить текст для {doc_id}: {exc}")
         raise self.retry(exc=exc, countdown=120) from exc
 
-    # Пересчитать fingerprints по полному тексту
-    doc_fp = winnow(text)
-    hashes = list(doc_fp)[: settings.MAX_FINGERPRINTS_PER_DOC]
-
-    from sqlalchemy import delete
-
-    with db_session() as session:
-        doc = session.get(Document, doc_id)
-        if doc is None:
-            return {"status": "doc_gone", "doc_id": doc_id}
-        doc.minio_key = key
-        # Удалить провизорные fingerprints и записать новые
-        session.execute(delete(Fingerprint).where(Fingerprint.doc_id == doc_id))
-        for i, hash_val in enumerate(hashes):
-            session.add(Fingerprint(doc_id=doc_id, hash_value=hash_val, position=i))
-        session.commit()
-
-    # Обновить MinHash LSH по полному тексту
-    add_to_lsh(f"doc:{doc_id}", text)
-
-    logger.info(
-        f"enrich_full_text: doc={doc_id} полный текст {len(text)} симв., "
-        f"fingerprints={len(hashes)}"
-    )
-    return {"status": "ok", "doc_id": doc_id, "chars": len(text), "fingerprints": len(hashes)}
-
 
 @celery_app.task(
     name="index.auto_approve_submission",
@@ -517,6 +532,24 @@ def _stage_work(
         logger.warning(f"Не удалось добавить работу {task_id!r} в отстойник: {e}")
 
 
+def _last_pmc_key() -> str | None:
+    """Ключ бакета после последней залитой статьи PMC — старт листинга.
+
+    Бакет отдаётся в лексикографическом порядке ключей, и ext_id вида
+    `pmc:PMC10000000` соответствует ключу `PMC10000000.1`. Берём максимальный
+    залитый и продолжаем после него.
+    """
+    from sqlalchemy import text as sql_text
+
+    with db_session() as session:
+        row = session.execute(sql_text(
+            "SELECT max(ext_id) FROM documents WHERE ext_id LIKE 'pmc:PMC%'"
+        )).first()
+    if not row or not row[0]:
+        return None
+    return row[0].split(":", 1)[1] + ".1"
+
+
 def _parser_for(source_type: str, cfg: dict[str, Any]) -> tuple[Any, dict[str, Any]]:
     """Инстанс парсера и совместимые с его fetch() аргументы по типу источника."""
     limit = cfg["limit"]
@@ -546,12 +579,200 @@ def _parser_for(source_type: str, cfg: dict[str, Any]) -> tuple[Any, dict[str, A
             "year_from": cfg.get("year_from"),
             "year_to": cfg.get("year_to"),
         }
+    elif source_type == "wikipedia_ru":
+        # Массовый источник: позиция — байтовое смещение в multistream-дампе.
+        # Раньше хранился номер статьи, и каждый прогон перечитывал дамп с
+        # начала: на 20 тысячах это стоило 6 минут из 25, дальше росло линейно
+        from wikipedia_ru import WikipediaRuParser as P
+        kwargs = {
+            "limit": limit,
+            "dump_path": query or None,     # query = путь к дампу, если задан
+            "start_offset": int(cfg.get("resume_token") or 0),
+        }
+    elif source_type == "core":
+        # Массовый источник: позиция — "год:смещение". Выборка режется по
+        # годам, потому что offset у CORE упирается в 100 000 (см. core.py)
+        from core import COREParser as P
+        kwargs = {
+            "limit": limit,
+            "query": query,
+            "year_from": cfg.get("year_from"),
+            "year_to": cfg.get("year_to"),
+            "resume_token": cfg.get("resume_token"),
+        }
+    elif source_type == "pmc_bulk":
+        from pmc_bulk import PMCBulkParser as P
+        kwargs = {
+            "limit": limit,
+            "resume_token": cfg.get("resume_token"),
+            # Токена ещё нет (первый прогон после ручных заливок) — начинаем
+            # после последней уже залитой статьи, иначе листинг часами
+            # перемалывает существующие как дубли
+            "start_after": None if cfg.get("resume_token") else _last_pmc_key(),
+        }
     else:
         raise ValueError(f"неизвестный тип источника: {source_type}")
 
     return P(), kwargs
 
 
+def _ingest_one_by_one(parser: Any, raw_docs: Any, prog: Any, run_id: int) -> tuple[bool, bool]:
+    """Обычный путь: документ за документом через add_document.
+
+    Подходит источникам, отдающим сотни статей: работает ORM-логика с
+    дедупликацией, индексацией в Elasticsearch и обогащением полным текстом.
+
+    Returns:
+        (отменён, исчерпан бюджет времени)
+    """
+    cancelled = exhausted = False
+
+    prog.stage = "index"
+    prog.count_fetched(len(raw_docs))
+    prog.log("info", f"получено {len(raw_docs)} документов, индексация")
+    _write_run(run_id, **prog.snapshot())
+
+    # Эмбеддинги диспатчим пачками, а не по одному документу: так worker-gpu
+    # кодирует батч разом и переписывает FAISS-индекс на диск раз в N добавлений,
+    # а не на каждый документ.
+    embed_batch: list[int] = []
+    batch_size = settings.EMBED_BATCH_SIZE
+
+    def _flush_embed() -> None:
+        if embed_batch:
+            celery_app.send_task(
+                "gpu.embed_documents", args=[list(embed_batch)], queue="queue.gpu"
+            )
+            embed_batch.clear()
+
+    for raw in raw_docs:
+        if not cancelled and prog.over_budget:
+            exhausted = True
+            prog.log("warning", f"бюджет времени {prog.budget_s:.0f}с исчерпан на индексации")
+        if cancelled or exhausted:
+            break
+        try:
+            doc = parser.transform(raw)
+            if not (doc and doc.get("title") and doc.get("ext_id")):
+                prog.count_result("skipped")
+                continue
+            result = add_document(doc, dispatch_embed=False)
+            prog.count_result(result.get("status", "error"))
+            if result.get("status") == "indexed":
+                embed_batch.append(result["doc_id"])
+                if len(embed_batch) >= batch_size:
+                    _flush_embed()
+        except Exception as e:
+            prog.count_result("error")
+            prog.log("warning", f"документ пропущен: {e}")
+            logger.warning(f"run_parser: ошибка документа: {e}")
+
+        if prog.should_flush():
+            cancelled = _write_run(run_id, **prog.snapshot())
+            prog.mark_flushed()
+            if cancelled:
+                prog.log("warning", "отмена по запросу из админки")
+
+    _flush_embed()
+    return cancelled, exhausted
+
+
+def _ingest_bulk(
+    parser: Any, raw_docs: Any, prog: Any, run_id: int, source_id: int
+) -> tuple[bool, bool]:
+    """Массовый путь: статьи приходят потоком и пишутся пачками через COPY.
+
+    Отличия от обычного пути и почему они нужны:
+    - парсер отдаёт генератор, поэтому счётчик «получено» растёт по ходу дела,
+      а не известен заранее;
+    - запись идёт пакетно (bulk_writer), иначе миллионы отпечатков занимают
+      недели вместо суток;
+    - позиция продолжения сохраняется в источнике, чтобы следующий прогон
+      начинал с места остановки, а не перечитывал дамп с начала.
+
+    Эмбеддинги здесь не диспатчатся: они считаются заметно медленнее заливки и
+    делали бы её узким местом. Векторы досчитываются отдельно —
+    `scripts/ops/reembed_missing.py`.
+
+    Returns:
+        (отменён, исчерпан бюджет времени)
+    """
+    from app.bulk_writer import connect, write_batch
+    from app.models import ParseSource
+
+    cancelled = exhausted = False
+    prog.stage = "index"
+    prog.log("info", "массовый источник: запись пачками")
+    _write_run(run_id, **prog.snapshot())
+
+    conn = connect()
+    batch: list[dict[str, Any]] = []
+    resume_token: str | None = None
+    batch_size = settings.BULK_WRITE_BATCH
+
+    def save_resume() -> None:
+        """Запомнить позицию в источнике — с неё продолжит следующий прогон."""
+        if resume_token is None:
+            return
+        with db_session() as session:
+            src = session.get(ParseSource, source_id)
+            if src:
+                src.resume_token = str(resume_token)
+                session.commit()
+
+    def flush() -> bool:
+        """Записать накопленное; True — попросили остановиться."""
+        nonlocal conn, batch
+        if not batch:
+            return False
+        conn, counts = write_batch(conn, batch, settings.MAX_FINGERPRINTS_PER_DOC)
+        for _ in range(counts["added"]):
+            prog.count_result("indexed")
+        for _ in range(counts["duplicates"]):
+            prog.count_result("duplicate")
+        batch = []
+        save_resume()
+        stop = _write_run(run_id, **prog.snapshot())
+        prog.mark_flushed()
+        return stop
+
+    try:
+        for raw in raw_docs:
+            if prog.over_budget:
+                exhausted = True
+                prog.log("warning", f"бюджет времени {prog.budget_s:.0f}с исчерпан")
+                break
+            try:
+                doc = parser.transform(raw)
+            except Exception as e:
+                prog.count_result("error")
+                logger.warning(f"run_parser bulk: ошибка документа: {e}")
+                continue
+
+            if not (doc and doc.get("ext_id") and doc.get("text")):
+                prog.count_result("skipped")
+                continue
+
+            # Позиция продолжения: у Википедии — номер статьи в дампе,
+            # у PMC — токен страницы бакета
+            resume_token = doc.get("dump_offset") or doc.get("resume_token") or resume_token
+            batch.append(doc)
+            prog.count_fetched(prog.fetched + 1)
+
+            if len(batch) >= batch_size and flush():
+                cancelled = True
+                prog.log("warning", "отмена по запросу из админки")
+                break
+
+        if not cancelled and flush():
+            cancelled = True
+    finally:
+        with contextlib.suppress(Exception):
+            conn.close()
+
+    return cancelled, exhausted
+
+
 def _write_run(run_id: int, **fields: Any) -> bool:
     """Записать прогресс прогона и вернуть True, если запрошена отмена.
 
@@ -608,6 +829,8 @@ def run_parser(self, source_id: int, run_id: int | None = None) -> dict[str, Any
             "year_from": src.year_from,
             "year_to": src.year_to,
             "limit": src.limit,
+            # Массовые источники продолжают с сохранённой позиции
+            "resume_token": src.resume_token,
         }
         src.last_status = "running"
         src.last_error = None
@@ -625,7 +848,15 @@ def run_parser(self, source_id: int, run_id: int | None = None) -> dict[str, Any
     prog.stage = "fetch"
     prog.log("info", f"старт: {cfg['source_type']} q={cfg.get('query') or '—'} limit={cfg['limit']}")
     _write_run(
-        run_id, status="running", celery_task_id=self.request.id, error=None, **prog.snapshot()
+        run_id,
+        status="running",
+        celery_task_id=self.request.id,
+        error=None,
+        # Отдельно от started_at (постановка в очередь): при массовом запуске
+        # между ними часы ожидания, и без этой отметки «длительность прогона»
+        # в отладке показывала очередь, а не работу
+        run_started_at=datetime.now(UTC),
+        **prog.snapshot(),
     )
 
     cancelled = False
@@ -654,53 +885,13 @@ def run_parser(self, source_id: int, run_id: int | None = None) -> dict[str, Any
         # fetch+transform без записи в JSONL — работаем in-memory
         raw_docs = parser.fetch(**fetch_kwargs, progress_cb=on_fetch_progress)
 
-        prog.stage = "index"
-        prog.count_fetched(len(raw_docs))
-        prog.log("info", f"получено {len(raw_docs)} документов, индексация")
-        _write_run(run_id, **prog.snapshot())
-
-        # Эмбеддинги диспатчим пачками, а не по одному документу: так worker-gpu
-        # кодирует батч разом и переписывает FAISS-индекс на диск раз в N добавлений,
-        # а не на каждый документ.
-        embed_batch: list[int] = []
-        batch_size = settings.EMBED_BATCH_SIZE
-
-        def _flush_embed() -> None:
-            if embed_batch:
-                celery_app.send_task(
-                    "gpu.embed_documents", args=[list(embed_batch)], queue="queue.gpu"
-                )
-                embed_batch.clear()
-
-        for raw in raw_docs:
-            if not cancelled and prog.over_budget:
-                exhausted = True
-                prog.log("warning", f"бюджет времени {prog.budget_s:.0f}с исчерпан на индексации")
-            if cancelled or exhausted:
-                break
-            try:
-                doc = parser.transform(raw)
-                if not (doc and doc.get("title") and doc.get("ext_id")):
-                    prog.count_result("skipped")
-                    continue
-                result = add_document(doc, dispatch_embed=False)
-                prog.count_result(result.get("status", "error"))
-                if result.get("status") == "indexed":
-                    embed_batch.append(result["doc_id"])
-                    if len(embed_batch) >= batch_size:
-                        _flush_embed()
-            except Exception as e:
-                prog.count_result("error")
-                prog.log("warning", f"документ пропущен: {e}")
-                logger.warning(f"run_parser: ошибка документа: {e}")
-
-            if prog.should_flush():
-                cancelled = _write_run(run_id, **prog.snapshot())
-                prog.mark_flushed()
-                if cancelled:
-                    prog.log("warning", "отмена по запросу из админки")
-
-        _flush_embed()
+        if getattr(parser, "bulk", False):
+            # Массовые источники (дамп Википедии, бакет PMC) отдают генератор:
+            # миллионы статей нельзя ни держать в памяти, ни писать по одной
+            # через ORM — для них отдельный путь с пакетной записью
+            cancelled, exhausted = _ingest_bulk(parser, raw_docs, prog, run_id, source_id)
+        else:
+            cancelled, exhausted = _ingest_one_by_one(parser, raw_docs, prog, run_id)
     except Exception as e:
         error_msg = str(e)[:500]
         prog.log("error", f"прогон упал: {error_msg}")

services/worker-indexer/requirements.txt

@@ -12,3 +12,4 @@ langdetect==1.0.9
 beautifulsoup4==4.12.3  # парсер CyberLeninka: детали статьи (fetch_article_details)
 pydantic-settings==2.2.1
 httpx==0.27.0
+socksio==1.0.0  # SOCKS5-прокси для httpx (CORE блокирует запросы из РФ, см. scripts/parsers/core.py)

services/worker-indexer/tests/test_winnowing.py

@@ -5,7 +5,9 @@ from app.algorithms.winnowing import (
     get_ngrams,
     hash_ngram,
     jaccard_similarity,
+    sample_evenly,
     winnow,
+    winnow_ordered,
 )
 
 # Достаточно длинный текст, чтобы окно Winnowing реально отработало
@@ -77,3 +79,57 @@ def test_compute_similarity_partial_overlap_is_between():
     modified = LONG + " добавлен ещё один совершенно новый хвост предложения здесь"
     sim = compute_similarity(LONG, modified)
     assert 0.0 < sim < 1.0
+
+
+# ─── Обрезка отпечатков по лимиту ────────────────────────────────────────────
+# Регрессия: winnow() возвращает set, и list(fp)[:limit] брал произвольное
+# подмножество — у длинного документа целые куски оставались без покрытия,
+# и списывание из них не находилось.
+
+
+def test_winnow_ordered_matches_winnow_by_content():
+    """Тот же набор отпечатков, что и у winnow, только с порядком."""
+    assert set(winnow_ordered(LONG)) == winnow(LONG)
+
+
+def test_winnow_ordered_has_no_duplicates():
+    ordered = winnow_ordered(LONG)
+    assert len(ordered) == len(set(ordered))
+
+
+def test_winnow_ordered_follows_text_order():
+    """Отпечатки начала текста идут раньше отпечатков продолжения."""
+    tail = " совершенно другой хвост про выпечку хлеба и закваску в тёплой печи"
+    ordered = winnow_ordered(LONG + tail)
+    head_prints = set(winnow_ordered(LONG))
+    positions = [i for i, h in enumerate(ordered) if h in head_prints]
+    # Отпечатки первой половины сосредоточены в начале списка, а не разбросаны
+    assert max(positions) < len(ordered)
+    assert positions[0] == 0
+
+
+def test_sample_evenly_keeps_everything_under_limit():
+    items = [1, 2, 3]
+    assert sample_evenly(items, 10) == items
+    assert sample_evenly(items, 0) == items  # 0 = без ограничения
+
+
+def test_sample_evenly_respects_limit():
+    items = list(range(1000))
+    assert len(sample_evenly(items, 100)) == 100
+
+
+def test_sample_evenly_covers_whole_document():
+    """Главное свойство: выборка растянута по всей длине, а не обрезана с начала."""
+    items = list(range(1000))
+    sampled = sample_evenly(items, 10)
+    assert sampled[0] == 0
+    assert sampled[-1] >= 900  # хвост документа тоже покрыт
+    assert sampled == sorted(sampled)  # порядок сохранён
+
+
+def test_sample_evenly_spreads_uniformly():
+    items = list(range(100))
+    sampled = sample_evenly(items, 10)
+    gaps = [b - a for a, b in zip(sampled, sampled[1:], strict=False)]
+    assert max(gaps) - min(gaps) <= 1  # шаг ровный