ci: run tests on pushes and pull requests

Reviewed-on: #38

.env.example

@@ -15,4 +15,3 @@ ADMIN_USERNAME=admin
 ADMIN_PASSWORD=change-me
 SESSION_SECRET=change-me-session-secret
 API_PORT=8000
-MCP_PORT=8001

.gitea/workflows/ci.yml

@@ -0,0 +1,24 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      DATABASE_URL: sqlite:///./ci.db
+      PYTHONUNBUFFERED: "1"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - run: python -m pip install --upgrade pip
+      - run: python -m pip install -r requirements.txt
+      - run: python -m pytest -q
+      - run: node --check app/static/admin.js

CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+## 0.8.1
+
+- Улучшены доступность, фильтры, состояния и адаптивность административного каталога.
+
+## 0.7.8
+
+- В колонке учёной степени отображаются все найденные степени без лишнего текста.
+
+## 0.7.7
+
+- Удалена неиспользуемая интеграция обмена данными и связанная документация и тесты.
+
+## 0.7.6
+
+- Возвращён еженедельный автоматический запуск обхода сотрудников.
+
+## 0.7.5
+
+- Production Compose запускает только API и PostgreSQL.
+
+## 0.7.4
+
+- Ускорена фильтрация сотрудников по учёной степени.
+
+## 0.7.3
+
+- Восстановлена проверка профилей сотрудников и хранение истории URL профиля.
+
+## 0.7.2
+
+- В каталоге сотрудников добавлены фильтр и колонка учёной степени.
+
+## 0.7.1
+
+- Добавлена кнопка «Проверить уволенных» для принудительной сверки статуса уволенных сотрудников с текущим списком источника.

MCP_DESCRIPTION.md

@@ -1,648 +0,0 @@
-# MCP: описание работы, структуры и тулзов
-
-Документ описывает MCP endpoint сервиса `miem-employees` по текущей реализации в `app/mcp.py`.
-
-## Где находится MCP
-
-- FastAPI router: `app.mcp.router`
-- Подключение к приложению: `app/main.py`
-- HTTP endpoint: `POST /mcp`
-- Локально при обычном запуске API: `http://localhost:8000/mcp`
-- В Docker Compose через отдельный сервис `mcp`: `http://localhost:8001/mcp`
-- Авторизация на уровне приложения: отсутствует. Заголовок `Authorization` не проверяется и не влияет на ответ.
-
-Если доступ к MCP нужно ограничить, это должно делаться внешним контуром: bind на localhost, VPN, firewall, reverse proxy или отдельная сетевая политика.
-
-## Протокол
-
-Endpoint принимает JSON-RPC 2.0 over HTTP.
-
-Общий формат запроса:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "method": "tools/list",
-  "params": {}
-}
-```
-
-Общий формат успешного ответа:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {}
-}
-```
-
-Общий формат ошибки:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "error": {
-    "code": -32601,
-    "message": "Method not found"
-  }
-}
-```
-
-Поддерживаемая версия MCP-протокола:
-
-```text
-2024-11-05
-```
-
-Имя сервиса:
-
-```text
-miem-employees
-```
-
-Версия сервера берется из `app.version.BACKEND_VERSION`.
-
-## Поддерживаемые JSON-RPC методы
-
-### initialize
-
-Возвращает метаданные MCP-сервера и capabilities.
-
-Запрос:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "method": "initialize",
-  "params": {}
-}
-```
-
-Ответ:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {
-    "protocolVersion": "2024-11-05",
-    "serverInfo": {
-      "name": "miem-employees",
-      "version": "0.5.0"
-    },
-    "capabilities": {
-      "tools": {}
-    }
-  }
-}
-```
-
-### tools/list
-
-Возвращает список доступных tools с JSON Schema для аргументов.
-
-Запрос:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "method": "tools/list",
-  "params": {}
-}
-```
-
-Ответ содержит массив `result.tools`.
-
-### tools/call
-
-Вызывает один tool по имени.
-
-Запрос:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "method": "tools/call",
-  "params": {
-    "name": "search_employees",
-    "arguments": {
-      "query": "Сергеев",
-      "limit": 20
-    }
-  }
-}
-```
-
-Ответ tool всегда заворачивается в MCP content-массив:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": 1,
-  "result": {
-    "content": [
-      {
-        "type": "text",
-        "text": "{\"items\":[]}"
-      }
-    ]
-  }
-}
-```
-
-Поле `text` содержит сериализованный JSON с `ensure_ascii=false`. Клиент должен распарсить это поле как JSON, если ему нужна структурированная нагрузка.
-
-## Ошибки
-
-- Неизвестный JSON-RPC метод: `code = -32601`, `message = "Method not found"`.
-- Исключения при обработке tool: `code = -32000`, `message` содержит текст исключения.
-- Если сущность не найдена внутри отдельных tools, HTTP и JSON-RPC ответ остаются успешными, а полезная нагрузка содержит `{"error": "not_found"}`.
-
-## Источники данных
-
-MCP читает данные из основной базы через SQLAlchemy session из `app.db.get_db`.
-
-Основные таблицы и модели:
-
-- `employees`: текущая карточка сотрудника, статус, профиль, `current_data`, checksum.
-- `employee_publications`: нормализованные публикации сотрудников с авторами, DOI, аннотацией, описанием, citation text и raw JSON из HSE Publications.
-- `crawl_runs`: история запусков парсинга.
-- `crawl_run_employee_changes`: детальные изменения сотрудников в рамках запуска.
-- `crawl_errors`: ошибки парсинга в рамках запуска.
-- `dataset_versions`: версии полного набора сотрудников.
-- `dataset_version_items`: состав конкретной версии набора сотрудников.
-
-## Общая структура employee payload
-
-Краткая карточка сотрудника:
-
-```json
-{
-  "profile_key": "staff:avsergeev",
-  "profile_id": "avsergeev",
-  "full_name": "Сергеев Алексей Викторович",
-  "status": "active",
-  "canonical_url": "https://www.hse.ru/staff/avsergeev",
-  "last_seen_at": "2026-05-14T10:00:00+00:00",
-  "dismissed_at": null
-}
-```
-
-В sync payload дополнительно отдается `checksum`.
-
-Полная карточка дополнительно содержит:
-
-```json
-{
-  "data": {
-    "contacts": {},
-    "sections": []
-  }
-}
-```
-
-`data` соответствует распарсенному JSON профиля сотрудника. Внутри `sections` могут быть секции с публикациями, курсами, ВКР, таблицами, ссылками и произвольными текстовыми блоками.
-
-## Tools
-
-### get_service_info
-
-Назначение: вернуть метаданные сервиса, список tools и текущую версию набора сотрудников.
-
-Аргументы: отсутствуют.
-
-Возвращает:
-
-```json
-{
-  "service_name": "miem-employees",
-  "backend_version": "0.5.0",
-  "protocolVersion": "2024-11-05",
-  "tools": [],
-  "dataset": {
-    "hash": "sha256",
-    "previous_hash": "sha256 или null",
-    "created_at": "2026-05-14T10:00:00+00:00",
-    "crawl_run_id": 123,
-    "employee_count": 100,
-    "active_count": 95,
-    "dismissed_count": 5
-  }
-}
-```
-
-Особенность: перед ответом сервис создает актуальную `dataset_version`, если текущий набор сотрудников еще не имеет версии.
-
-### sync_employees
-
-Назначение: синхронизировать клиентский кэш сотрудников по hash набора данных.
-
-Аргументы:
-
-```json
-{
-  "client_hash": "sha256 или null",
-  "include_data": true
-}
-```
-
-- `client_hash`: hash версии, которая уже есть у клиента. Если не передан, отдается полный snapshot.
-- `include_data`: управляет включением полного `data` в карточки сотрудников. По умолчанию `true`.
-
-Полный ответ без `client_hash`:
-
-```json
-{
-  "mode": "full",
-  "from_hash": null,
-  "to_hash": "current-sha256",
-  "dataset": {},
-  "items": []
-}
-```
-
-Если клиентский hash совпадает с текущим:
-
-```json
-{
-  "mode": "delta",
-  "from_hash": "current-sha256",
-  "to_hash": "current-sha256",
-  "dataset": {},
-  "changes": {
-    "added": [],
-    "updated": [],
-    "dismissed": [],
-    "removed": []
-  }
-}
-```
-
-Если `client_hash` неизвестен серверу:
-
-```json
-{
-  "mode": "full",
-  "from_hash": "missing",
-  "to_hash": "current-sha256",
-  "dataset": {},
-  "items": [],
-  "reason": "unknown_client_hash"
-}
-```
-
-Если `client_hash` найден и отличается от текущего:
-
-```json
-{
-  "mode": "delta",
-  "from_hash": "old-sha256",
-  "to_hash": "current-sha256",
-  "dataset": {},
-  "changes": {
-    "added": [],
-    "updated": [],
-    "dismissed": [],
-    "removed": []
-  }
-}
-```
-
-Логика delta:
-
-- `added`: сотрудник появился в новой версии.
-- `updated`: изменился checksum или статус, и сотрудник активен.
-- `dismissed`: сотрудник есть в новой версии, но получил статус `dismissed`.
-- `removed`: `profile_key` был в старой версии, но отсутствует в новой.
-
-Hash набора считается по отсортированному списку `{profile_key, status, checksum}`.
-
-### search_employees
-
-Назначение: найти сотрудников по ФИО или canonical URL.
-
-Аргументы:
-
-```json
-{
-  "query": "Сергеев",
-  "status": "active",
-  "limit": 20
-}
-```
-
-- `query`: обязательный по schema, но в коде пустая строка означает поиск без текстового фильтра.
-- `status`: опционально, только `active` или `dismissed`.
-- `limit`: максимум 100, по умолчанию 20.
-
-Возвращает массив кратких employee payload без `data`:
-
-```json
-[
-  {
-    "profile_key": "staff:avsergeev",
-    "profile_id": "avsergeev",
-    "full_name": "Сергеев Алексей Викторович",
-    "status": "active",
-    "canonical_url": "https://www.hse.ru/staff/avsergeev",
-    "last_seen_at": "2026-05-14T10:00:00+00:00",
-    "dismissed_at": null
-  }
-]
-```
-
-### get_employee
-
-Назначение: получить одну карточку сотрудника.
-
-Аргументы:
-
-```json
-{
-  "profile_id_or_url": "avsergeev"
-}
-```
-
-Поиск выполняется по:
-
-- `profile_key`
-- `profile_id`
-- точному `canonical_url`
-- частичному совпадению `canonical_url`
-
-Возвращает полный employee payload с `data`.
-
-Если сотрудник не найден:
-
-```json
-{
-  "error": "not_found"
-}
-```
-
-### list_employee_publications
-
-Назначение: вернуть публикации сотрудника. Если есть нормализованные строки в `employee_publications`, tool возвращает детальные публикационные данные: авторов, DOI, аннотацию, описание, citation text, год, тип, язык, статус и ссылки. Если детальная таблица еще не заполнена, tool использует старый fallback из `employees.current_data.sections[].publications`.
-
-Аргументы:
-
-```json
-{
-  "profile_id_or_url": "avsergeev"
-}
-```
-
-Поиск сотрудника выполняется так же, как в `get_employee`: по `profile_key`, `profile_id`, точному или частичному `canonical_url`.
-
-Порядок источников:
-
-- сначала `employee_publications`, отсортированные по году, названию и внутреннему id;
-- если записей нет, секции `current_data.sections` с `type = "publications"` и массивами `publications`.
-
-Ответ:
-
-```json
-{
-  "employee": {
-    "profile_key": "org_person:803294906",
-    "profile_id": "803294906",
-    "full_name": "Борисов Сергей Петрович",
-    "status": "active",
-    "canonical_url": "https://www.hse.ru/org/persons/803294906",
-    "last_seen_at": "2026-05-14T10:00:00+00:00",
-    "dismissed_at": null
-  },
-  "items": [
-    {
-      "id": "888959076",
-      "publication_id": "888959076",
-      "title": "Название публикации",
-      "text": "Краткое описание или citation",
-      "url": "https://publications.hse.ru/view/888959076",
-      "year": 2023,
-      "type": "ARTICLE",
-      "publication_type": "ARTICLE",
-      "language": "ru",
-      "status": 1,
-      "doi_url": "https://doi.org/10.53921/18195822_2023_23_4_624",
-      "other_url": "https://example.test",
-      "document_url": "https://example.test/file.pdf",
-      "citation_text": "Авторы. Название публикации // Журнал. 2023.",
-      "annotation": {
-        "ru": "Аннотация",
-        "en": "Abstract"
-      },
-      "description": {
-        "main": "Авторы. Название публикации // Журнал. 2023."
-      },
-      "authors": [
-        {
-          "id": "803294906",
-          "href": "https://www.hse.ru/org/persons/803294906",
-          "title_ru": "Борисов С. П.",
-          "title_en": "",
-          "reverse_title_ru": "С. П. Борисов",
-          "reverse_title_en": "",
-          "alt_name": "S. P. Borisov",
-          "other_name": null,
-          "is_current_employee": true
-        }
-      ]
-    }
-  ]
-}
-```
-
-В fallback-режиме из `current_data` старые элементы могут содержать только базовые поля `title`, `text`, `url` и `id`.
-
-Если сотрудник не найден:
-
-```json
-{
-  "items": []
-}
-```
-
-Если сотрудник найден, но публикаций нет:
-
-```json
-{
-  "employee": {},
-  "items": []
-}
-```
-
-### list_employee_courses
-
-Назначение: вернуть курсы преподавания сотрудника из распарсенных секций профиля.
-
-Аргументы:
-
-```json
-{
-  "profile_id_or_url": "avsergeev"
-}
-```
-
-Сервис ищет секции `current_data.sections` с `type = "courses_by_year"` и объединяет массивы `courses`.
-
-Ответ:
-
-```json
-{
-  "employee": {},
-  "items": [
-    {
-      "title": "Название курса",
-      "url": "https://..."
-    }
-  ]
-}
-```
-
-Если сотрудник или данные профиля отсутствуют:
-
-```json
-{
-  "items": []
-}
-```
-
-### get_crawl_status
-
-Назначение: вернуть последний запуск парсинга.
-
-Аргументы: отсутствуют.
-
-Ответ:
-
-```json
-{
-  "id": 123,
-  "status": "completed",
-  "source_url": "https://miem.hse.ru/persons",
-  "started_at": "2026-05-14T10:00:00+00:00",
-  "finished_at": "2026-05-14T10:10:00+00:00",
-  "found_count": 100,
-  "parsed_count": 98,
-  "error_count": 2,
-  "dismissed_count": 1
-}
-```
-
-Если запусков еще не было:
-
-```json
-{
-  "status": "never_run"
-}
-```
-
-### get_crawl_run_details
-
-Назначение: вернуть детальную информацию по конкретному запуску парсинга: summary, изменения сотрудников и ошибки.
-
-Аргументы:
-
-```json
-{
-  "run_id": 123
-}
-```
-
-Ответ:
-
-```json
-{
-  "id": 123,
-  "source_url": "https://miem.hse.ru/persons",
-  "status": "completed",
-  "status_display": "Завершен",
-  "started_at": "2026-05-14T10:00:00+00:00",
-  "finished_at": "2026-05-14T10:10:00+00:00",
-  "started_display": "14.05.2026 13:00",
-  "finished_display": "14.05.2026 13:10",
-  "found_count": 100,
-  "parsed_count": 98,
-  "new_count": 3,
-  "error_count": 2,
-  "dismissed_count": 1,
-  "processed_count": 100,
-  "progress_percent": 100.0,
-  "message": null,
-  "changes_detail_available": true,
-  "changes": {
-    "new": [],
-    "missing_from_source": [],
-    "dismissed": []
-  },
-  "errors": []
-}
-```
-
-Если запуск не найден:
-
-```json
-{
-  "error": "not_found"
-}
-```
-
-## Примеры curl
-
-Список tools:
-
-```bash
-curl http://localhost:8001/mcp \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
-```
-
-Поиск сотрудника:
-
-```bash
-curl http://localhost:8001/mcp \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"search_employees","arguments":{"query":"Сергеев","limit":5}}}'
-```
-
-Полная синхронизация:
-
-```bash
-curl http://localhost:8001/mcp \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"sync_employees","arguments":{"include_data":false}}}'
-```
-
-Delta-синхронизация:
-
-```bash
-curl http://localhost:8001/mcp \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"sync_employees","arguments":{"client_hash":"known-sha256","include_data":true}}}'
-```
-
-## Как MCP используется клиентом
-
-1. Клиент вызывает `initialize` и проверяет `protocolVersion`.
-2. Клиент вызывает `tools/list`, чтобы получить актуальный список tools и input schemas.
-3. Для поиска и точечных запросов клиент вызывает `tools/call` с `search_employees`, `get_employee`, `list_employee_publications`, `list_employee_courses`, `get_crawl_status` или `get_crawl_run_details`.
-4. Для локального кэша клиент вызывает `get_service_info` или `sync_employees`.
-5. Клиент хранит последний `dataset.hash`.
-6. При следующей синхронизации клиент передает hash как `client_hash`.
-7. Сервер возвращает пустую delta, delta с изменениями или полный snapshot, если hash неизвестен.
-
-## Важные особенности реализации
-
-- MCP endpoint read-only: tools не запускают парсинг и не меняют сотрудников напрямую.
-- `get_service_info` и `sync_employees` могут создать новую запись `dataset_versions`, если состояние сотрудников изменилось и новой версии еще нет.
-- Все tool payloads возвращаются как JSON-строка внутри `content[0].text`.
-- `search_employees` ищет через `ilike` по `full_name` и `canonical_url`.
-- `get_employee` допускает частичный URL, поэтому строка `133709486` может найти `https://www.hse.ru/org/persons/133709486`.
-- Временные значения сериализуются через `isoformat()`, display-поля для админских payload формируются в часовом поясе `Europe/Moscow`.

README.md

@@ -1,132 +1,136 @@
-# MIEM Employees Server
-
-Сервис собирает сотрудников МИЭМ с сайта ВШЭ, хранит карточки и историю обновлений в Postgres, показывает минимальную админку и отдает read-only MCP endpoint для ИИ-агентов.
-
-## Архитектура
-
-- `api`: FastAPI, REST API, HTML-админка, healthcheck.
+# MIEM Employees Server
+
+Сервис собирает сотрудников МИЭМ с сайта ВШЭ, хранит карточки и историю обновлений в Postgres и показывает минимальную админку.
+
+## Архитектура
+
+- `api`: FastAPI, REST API, HTML-админка и healthcheck.
 - `worker`: weekly scheduler, который запускает парсинг по `CRAWL_CRON`.
-- `mcp`: открытый HTTP MCP endpoint для ИИ-агентов.
-- `postgres`: основная БД.
-
-Парсер использует фиксированный источник сотрудников, по умолчанию `https://miem.hse.ru/persons`. Для каждой карточки сохраняются ФИО, должности, год начала работы, контакты, идентификаторы, вкладки профиля, секции, публикации, курсы, ВКР, JSON-снапшот и сжатый HTML-снапшот. Детальные публикации дополнительно нормализуются в отдельную таблицу `employee_publications`. Ссылки обходятся только из меню профиля самого сотрудника (`person-menu`), например `#sci`, `#teaching`, `#main`.
-
-## Переменные окружения
-
-Скопируйте `.env.example` в `.env` и поменяйте секреты:
-
-```bash
-cp .env.example .env
-```
-
-Основные настройки:
-
-- `DATABASE_URL`: строка подключения SQLAlchemy.
+- `postgres`: основная БД.
+
+Парсер использует фиксированный источник сотрудников, по умолчанию `https://miem.hse.ru/persons`. Для каждой карточки сохраняются ФИО, должности, год начала работы, контакты, идентификаторы, вкладки профиля, секции, публикации, курсы, ВКР, новости, JSON-снапшот и сжатый HTML-снапшот. Детальные публикации дополнительно нормализуются в отдельную таблицу `employee_publications`, а новости из блока «В новостях» — в `employee_news_links`. Ссылки обходятся только из меню профиля самого сотрудника (`person-menu`), например `#sci`, `#teaching`, `#main`.
+
+## Переменные окружения
+
+Скопируйте `.env.example` в `.env` и поменяйте секреты:
+
+```bash
+cp .env.example .env
+```
+
+Основные настройки:
+
+- `DATABASE_URL`: строка подключения SQLAlchemy.
 - `SOURCE_URL`: список сотрудников МИЭМ.
 - `CRAWL_CRON`: расписание в формате crontab, по умолчанию `0 3 * * 1`.
-- `CRAWL_LIMIT`: опциональный лимит профилей для тестового запуска.
-- `ADMIN_USERNAME`, `ADMIN_PASSWORD`: логин и пароль админки.
-- `SESSION_SECRET`: секрет подписи cookie.
-- `PARSER_USE_PLAYWRIGHT`: включение Playwright-рендера динамических вкладок.
+- `CRAWL_LIMIT`: опциональный лимит профилей для тестового запуска.
+- `ADMIN_USERNAME`, `ADMIN_PASSWORD`: логин и пароль админки.
+- `SESSION_SECRET`: секрет подписи cookie.
+- `PARSER_USE_PLAYWRIGHT`: включение Playwright-рендера динамических вкладок.
+- `DISMISSAL_CONFIRMATION_RUNS`: сколько последовательных проверок недоступности нужно для увольнения, по умолчанию `3`.
+- `MAX_AUTO_DISMISSALS_PER_RUN`: защитный лимит массовых автоматических увольнений за один запуск, по умолчанию `25`.
+
+## Локальный запуск
+
+```bash
+python -m venv .venv
+.venv\Scripts\activate
+pip install -r requirements.txt
+uvicorn app.main:app --reload
+```
+
+Админка: `http://localhost:8000/admin`.
+
+В админке доступны:
+
+- «Обзор»: статистика, последний добавленный сотрудник, прогресс парсинга и ручной запуск.
+- «Сотрудники»: поиск, фильтры, сортировка, пагинация и выбор колонок. По умолчанию показаны ФИО, статус, должности, дата последнего обнаружения и внешний профиль. В диалоге колонок доступны наборы «Проверка», «Контакты» и «Все поля»; ранее сохранённый выбор сохраняется.
+- «Запуски»: история обходов, ошибки и доступный индикатор прогресса.
 
-## Локальный запуск
+Все фильтры применяются кнопкой «Применить фильтры» с переходом на первую страницу. «Сбросить» очищает условия; при устаревшем номере страницы каталог возвращает первую. Подписи полей показывают выбранные условия, над таблицей указан диапазон результатов. Пояснения дат и статусов находятся под фильтрами.
 
-```bash
-python -m venv .venv
-.venv\Scripts\activate
-pip install -r requirements.txt
-uvicorn app.main:app --reload
-```
+Каталог поддерживает навигацию с клавиатуры и системный диалог колонок с Escape и возвратом фокуса. На узких экранах таблица прокручивается внутри страницы, колонка ФИО закреплена. Используется системный шрифт без внешних загрузок.
 
-Админка: `http://localhost:8000/admin`.
+Каталог формируется сервером: отдельная клиентская загрузка списка не нужна, переход показывает браузер. Пустой результат предлагает сбросить фильтры, пустая база — запустить парсинг. При ошибке базы каталог возвращает HTTP 503 и предлагает повторить загрузку с теми же фильтрами. При обновлении прогресса показывается состояние загрузки; при ошибке сохраняются последние значения с предупреждением об их актуальности и кнопкой «Повторить». Автоматические попытки продолжаются каждые 4 секунды, запрос ограничен 15 секундами; параллельные запросы не запускаются.
+
+## Docker Compose
+
+```bash
+docker compose up -d --build --remove-orphans
+```
+
+По умолчанию:
+
+- API и админка: `http://localhost:8000`
+- PostgreSQL: `postgres:5432` внутри сети Compose; порт на хост не опубликован.
 
-В админке доступны:
-
-- `Dashboard`: общая статистика, последний добавленный сотрудник, прогресс текущего/последнего парсинга и ручной запуск.
-- `Directory`: настраиваемая таблица сотрудников с фильтрами, сортировкой, пагинацией и выбором колонок.
-- `Runs`: история запусков, ошибки и progress bar.
-
-## Docker Compose
-
-```bash
-docker compose up --build
-```
-
-По умолчанию:
-
-- API и админка: `http://localhost:8000`
-- MCP: `http://localhost:8001/mcp`
-- Postgres: `localhost:5432`
-
-Таблицы создаются приложением при старте. При обновлении существующей базы приложение также добавляет недостающие runtime-колонки, например `crawl_runs.skipped_count`. SQL-миграции для ручного применения лежат в `migrations/`.
-
-## Наполнение БД
-
-Основная карточка сотрудника хранится в `employees`: профиль, статус, даты обнаружения/увольнения, текущий JSON `current_data`, checksum и версия парсера. История успешных изменений сохраняется в `employee_snapshots` вместе с JSON-снимком и сжатым HTML профиля.
-
-Публикации теперь хранятся в двух видах:
-
-- краткий список остается внутри `employees.current_data.sections[].publications` для обратной совместимости;
-- детальные записи сохраняются в `employee_publications` и связываются с сотрудником через `employee_id`.
-
-`employee_publications` содержит `publication_id`, название, год, тип публикации, язык, статус, ссылку на карточку HSE Publications, DOI, внешние/document-ссылки, citation text, аннотацию, описание, авторов, raw JSON ответа `searchPubs` и `source_hash` для безопасного повторного upsert. Уникальность поддерживается по `(employee_id, publication_id)` и `(employee_id, source_hash)`, поэтому повторный crawl не должен создавать дубликаты.
-
-`list_employee_publications` сначала читает `employee_publications`; если детальных строк еще нет, возвращает старые публикации из `current_data`.
-
-## Парсинг
-
-Weekly worker запускается по `CRAWL_CRON`. Ручной запуск доступен в админке на `Dashboard` и странице `Runs` или через REST:
-
-```bash
-curl -X POST http://localhost:8000/api/crawl-runs --cookie "miem_admin_session=..."
-```
-
-Алгоритм обновления:
-
-- найденные сотрудники получают статус `active` и обновленный `last_seen_at`;
-- новые сотрудники добавляются в `employees`;
-- количество новых сотрудников за запуск сохраняется в `crawl_runs.new_count`;
-- публикации из HSE Publications записываются в `employee_publications`, а краткий список остается в JSON профиля;
-- активные сотрудники, исчезнувшие из текущего списка источника, получают статус `dismissed` и `dismissed_at`;
+Compose запускает `api`, `worker` и `postgres`. API привязан к localhost; для внешнего доступа нужен настроенный reverse proxy. MCP удалён, endpoint `/mcp` отсутствует; REST API данных требует сессию администратора.
+
+Таблицы создаются приложением при старте. При обновлении существующей базы приложение также добавляет недостающие runtime-колонки, например `crawl_runs.skipped_count`. SQL-миграции для ручного применения лежат в `migrations/`.
+
+## Наполнение БД
+
+Основная карточка сотрудника хранится в `employees`: профиль, статус, даты обнаружения/увольнения, текущий JSON `current_data`, checksum и версия парсера. История успешных изменений сохраняется в `employee_snapshots` вместе с JSON-снимком и сжатым HTML профиля.
+
+Публикации теперь хранятся в двух видах:
+
+- краткий список остается внутри `employees.current_data.sections[].publications` для обратной совместимости;
+- детальные записи сохраняются в `employee_publications` и связываются с сотрудником через `employee_id`.
+
+`employee_publications` содержит `publication_id`, название, год, тип публикации, язык, статус, ссылку на карточку HSE Publications, DOI, внешние/document-ссылки, citation text, аннотацию, описание, авторов, raw JSON ответа `searchPubs` и `source_hash` для безопасного повторного upsert. Уникальность поддерживается по `(employee_id, publication_id)` и `(employee_id, source_hash)`, поэтому повторный crawl не должен создавать дубликаты.
+
+Новости сотрудников также хранятся в двух видах:
+
+- краткий список остается внутри `employees.current_data.sections[].news_links`;
+- нормализованные карточки из вкладки «В новостях» сохраняются в `employee_news_links`.
+
+`employee_news_links` содержит название новости, ссылку, краткое описание, дату публикации, год публикации, raw JSON карточки и `source_hash`. Уникальность поддерживается по `(employee_id, url)` и `(employee_id, source_hash)`, поэтому повторный crawl не создает дубликаты.
+
+## Парсинг
+
+Worker запускает обход по `CRAWL_CRON`. Ручной запуск также доступен в админке на `Dashboard` и странице `Runs` или через REST:
+
+```bash
+curl -X POST http://localhost:8000/api/crawl-runs --cookie "miem_admin_session=..."
+```
+
+Алгоритм обновления:
+
+- найденные сотрудники получают статус `active` и обновленный `last_seen_at`;
+- новые сотрудники добавляются в `employees`;
+- если профиль перенесен на другой URL, он сопоставляется с прежней записью по единственному точному совпадению ФИО;
+- старые URL сохраняются в истории `employee_profile_urls`;
+- количество новых сотрудников за запуск сохраняется в `crawl_runs.new_count`;
+- публикации из HSE Publications записываются в `employee_publications`, а краткий список остается в JSON профиля;
+- новости из блока «В новостях» записываются в `employee_news_links`, а краткий список остается в JSON профиля;
+- один `404` старого профиля переводит сотрудника в статус `verification_required`, а не в `dismissed`;
+- статус `dismissed` устанавливается только после нескольких последовательных проверок `404`/`410`;
+- сетевые ошибки и ответы `5xx` не считаются подтверждением увольнения;
+- если число кандидатов на увольнение превышает защитный лимит, автоматическое увольнение приостанавливается;
+- кнопка «Проверить уволенных» сверяет только их profile_key с текущим списком источника и возвращает найденных сотрудников в `active` без обновления содержимого профиля;
 - каждый успешный новый или измененный разбор сохраняет запись в `employee_snapshots`;
-- неизмененные профили учитываются в `crawl_runs.skipped_count` и не получают новый snapshot.
-
-Во время выполнения парсинга `found_count`, `parsed_count`, `skipped_count` и `error_count` обновляются в базе. Админка опрашивает `/api/crawl-runs/latest` и показывает прогресс как `(parsed_count + skipped_count + error_count) / found_count`.
-
-## MCP
-
-Endpoint: `POST /mcp`, без авторизации на уровне приложения.
-
-Поддерживаемые tools:
-
-- `get_service_info()`
-- `sync_employees(client_hash?, include_data?)`
-- `search_employees(query, status?, limit?)`
-- `get_employee(profile_id_or_url)`
-- `list_employee_publications(profile_id_or_url)` — публикации сотрудника; при наличии данных из `employee_publications` возвращает авторов, DOI, аннотацию, описание, citation text, год, тип, язык, статус и ссылку HSE Publications.
-- `list_employee_courses(profile_id_or_url)`
-- `get_crawl_status()`
-- `get_crawl_run_details(run_id)`
-
-`get_service_info` возвращает метаданные сервиса, список tools и текущую версию набора сотрудников. `sync_employees` отдает полный snapshot или delta по `client_hash`; checksum набора строится по сотрудникам, их статусам и текущим checksums. Ответы tools возвращаются как JSON-строка внутри MCP `content[0].text`.
-
-Пример локального запроса списка tools:
-
-```bash
-curl http://localhost:8001/mcp \
-  -H "Content-Type: application/json" \
-  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
-```
-
-Если MCP нужно ограничить, делайте это на сетевом уровне: localhost binding, VPN, firewall, reverse proxy или другой внешний контур доступа.
-
+- неизмененные профили учитываются в `crawl_runs.skipped_count` и не получают новый snapshot.
+
+Во время выполнения парсинга `found_count`, `parsed_count`, `skipped_count` и `error_count` обновляются в базе. Админка опрашивает `/api/crawl-runs/latest` и показывает прогресс как `(parsed_count + skipped_count + error_count) / found_count`.
+
 ## Обслуживание
-
-```bash
+
+```bash
 docker compose logs -f api
 docker compose logs -f worker
-docker compose exec postgres pg_dump -U miem miem_workers > backup.sql
-docker compose down
+docker compose exec postgres pg_dump -U miem miem_workers > backup.sql
+docker compose down
+```
+
+## Проверки
+
+После установки зависимостей из `requirements.txt` выполните:
+
+```bash
+python -m pytest -q
+node --check app/static/admin.js
 ```
 
-Версия сервиса: `0.6.2`. Админка всегда показывает версии backend и frontend в footer.
+Тесты с данными используют временную SQLite; отдельные API smoke-тесты запускают приложение с его текущей конфигурацией. Браузерная проверка: `pip install playwright`, `python -m playwright install chromium`, затем `python tests/browser_admin.py`. Она проверяет реальный рендеринг страниц, клавиатуру, диалог, фильтры и восстановление прогресса после ошибки. Скриншоты сохраняются во временную папку; путь выводится в конце.
+
+Версия сервиса: `0.8.1`. Админка всегда показывает версии backend и frontend в footer.

app/admin.py

@@ -1,219 +1,247 @@
-from fastapi import APIRouter, BackgroundTasks, Depends, Form, Request
-from fastapi.responses import HTMLResponse, RedirectResponse
-from fastapi.templating import Jinja2Templates
-from sqlalchemy import desc, func, select
-from sqlalchemy.orm import Session
-
-from app.config import Settings, get_settings
-from app.db import SessionLocal, get_db
-from app.models import CrawlError, CrawlRun, Employee
-from app.security import SESSION_COOKIE, require_admin, sign_session, verify_admin
-from app.services.admin_data import (
-    employee_detail_payload,
-    format_admin_datetime,
-    list_employees_page,
-    run_detail_payload,
-    run_payload,
-    stats_payload,
-)
-from app.services.crawl_control import get_running_run, run_crawl_if_idle
-from app.services.crawler import refresh_employee
-from app.version import BACKEND_VERSION, FRONTEND_VERSION
-
-router = APIRouter(prefix="/admin")
-templates = Jinja2Templates(directory="app/templates")
-
-
-@router.get("", response_class=HTMLResponse)
-def dashboard(request: Request, db: Session = Depends(get_db), settings: Settings = Depends(get_settings)):
-    require_admin(request, settings)
-    counts = stats_payload(db)
-    counts["runs"] = db.scalar(select(func.count()).select_from(CrawlRun)) or 0
-    counts["errors"] = db.scalar(select(func.count()).select_from(CrawlError)) or 0
-    run_models = db.scalars(select(CrawlRun).order_by(desc(CrawlRun.started_at)).limit(5)).all()
-    runs = [run_payload(run) for run in run_models]
-    return _render(request, "dashboard.html", {"counts": counts, "runs": runs, "latest_run": runs[0] if runs else None})
-
-
-@router.get("/login", response_class=HTMLResponse)
-def login_form(request: Request):
-    return _render(request, "login.html", {"error": None})
-
-
-@router.post("/login")
-def login(
-    request: Request,
-    username: str = Form(...),
-    password: str = Form(...),
-    settings: Settings = Depends(get_settings),
-):
-    if not verify_admin(username, password, settings):
-        return _render(request, "login.html", {"error": "Неверный логин или пароль"}, status_code=401)
-    redirect = RedirectResponse("/admin", status_code=303)
-    redirect.set_cookie(SESSION_COOKIE, sign_session(username, settings), httponly=True, samesite="lax")
-    return redirect
-
-
-@router.post("/logout")
-def logout():
-    redirect = RedirectResponse("/admin/login", status_code=303)
-    redirect.delete_cookie(SESSION_COOKIE)
-    return redirect
-
-
-@router.get("/employees", response_class=HTMLResponse)
-def employees(
-    request: Request,
-    status: str | None = None,
-    q: str | None = None,
-    settings: Settings = Depends(get_settings),
-):
-    require_admin(request, settings)
-    return RedirectResponse("/admin/directory", status_code=303)
-
-
-@router.get("/directory", response_class=HTMLResponse)
-def directory(
-    request: Request,
-    status: str | None = None,
-    q: str | None = None,
-    started_from: str | None = None,
+from fastapi import APIRouter, BackgroundTasks, Depends, Form, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+from sqlalchemy import desc, func, select
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from app.config import Settings, get_settings
+from app.db import SessionLocal, get_db
+from app.models import CrawlError, CrawlRun, Employee
+from app.security import SESSION_COOKIE, require_admin, sign_session, verify_admin
+from app.services.admin_data import (
+    employee_detail_payload,
+    format_admin_datetime,
+    list_employees_page,
+    run_detail_payload,
+    run_payload,
+    stats_payload,
+)
+from app.services.crawl_control import get_running_run, run_crawl_if_idle
+from app.services.crawler import refresh_dismissed_status, refresh_employee
+from app.version import BACKEND_VERSION, FRONTEND_VERSION
+
+router = APIRouter(prefix="/admin")
+templates = Jinja2Templates(directory="app/templates")
+
+
+@router.get("", response_class=HTMLResponse)
+def dashboard(request: Request, db: Session = Depends(get_db), settings: Settings = Depends(get_settings)):
+    require_admin(request, settings)
+    counts = stats_payload(db)
+    counts["runs"] = db.scalar(select(func.count()).select_from(CrawlRun)) or 0
+    counts["errors"] = db.scalar(select(func.count()).select_from(CrawlError)) or 0
+    run_models = db.scalars(select(CrawlRun).order_by(desc(CrawlRun.started_at)).limit(5)).all()
+    runs = [run_payload(run) for run in run_models]
+    return _render(request, "dashboard.html", {"counts": counts, "runs": runs, "latest_run": runs[0] if runs else None})
+
+
+@router.get("/login", response_class=HTMLResponse)
+def login_form(request: Request):
+    return _render(request, "login.html", {"error": None})
+
+
+@router.post("/login")
+def login(
+    request: Request,
+    username: str = Form(...),
+    password: str = Form(...),
+    settings: Settings = Depends(get_settings),
+):
+    if not verify_admin(username, password, settings):
+        return _render(request, "login.html", {"error": "Неверный логин или пароль"}, status_code=401)
+    redirect = RedirectResponse("/admin", status_code=303)
+    redirect.set_cookie(SESSION_COOKIE, sign_session(username, settings), httponly=True, samesite="lax")
+    return redirect
+
+
+@router.post("/logout")
+def logout():
+    redirect = RedirectResponse("/admin/login", status_code=303)
+    redirect.delete_cookie(SESSION_COOKIE)
+    return redirect
+
+
+@router.get("/employees", response_class=HTMLResponse)
+def employees(
+    request: Request,
+    status: str | None = None,
+    q: str | None = None,
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    return RedirectResponse("/admin/directory", status_code=303)
+
+
+@router.get("/directory", response_class=HTMLResponse)
+def directory(
+    request: Request,
+    status: str | None = None,
+    q: str | None = None,
+    started_from: str | None = None,
     started_to: str | None = None,
     has_email: str | None = None,
-    sort: str = "full_name",
-    direction: str = "asc",
-    limit: int = 50,
-    offset: int = 0,
-    db: Session = Depends(get_db),
-    settings: Settings = Depends(get_settings),
-):
-    require_admin(request, settings)
-    parsed_started_from = _parse_date(started_from)
-    parsed_started_to = _parse_date(started_to)
+    has_academic_degree: str | None = None,
+    sort: str = "full_name",
+    direction: str = "asc",
+    limit: int = 50,
+    offset: int = 0,
+    db: Session = Depends(get_db),
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    parsed_started_from = _parse_date(started_from)
+    parsed_started_to = _parse_date(started_to)
     parsed_has_email = None if has_email in (None, "") else has_email == "true"
-    page = list_employees_page(
-        db,
-        status=status,
-        q=q,
-        started_from=parsed_started_from,
-        started_to=parsed_started_to,
-        has_email=parsed_has_email,
-        sort=sort,
-        direction=direction,
-        limit=limit,
-        offset=offset,
-    )
-    return _render(
-        request,
-        "directory.html",
-        {
-            "page": page,
-            "filters": {
-                "status": status or "",
-                "q": q or "",
-                "started_from": started_from or "",
-                "started_to": started_to or "",
+    parsed_has_academic_degree = None if has_academic_degree in (None, "") else has_academic_degree == "true"
+    try:
+        page = list_employees_page(
+            db,
+            status=status,
+            q=q,
+            started_from=parsed_started_from,
+            started_to=parsed_started_to,
+            has_email=parsed_has_email,
+            has_academic_degree=parsed_has_academic_degree,
+            sort=sort,
+            direction=direction,
+            limit=limit,
+            offset=offset,
+        )
+    except SQLAlchemyError:
+        db.rollback()
+        return _render(request, "directory_error.html", {}, status_code=503)
+    return _render(
+        request,
+        "directory.html",
+        {
+            "page": page,
+            "filters": {
+                "status": status or "",
+                "q": q or "",
+                "started_from": started_from or "",
+                "started_to": started_to or "",
                 "has_email": has_email or "",
-                "sort": sort,
-                "direction": direction,
-                "limit": page["limit"],
-                "offset": offset,
-            },
-        },
-    )
-
-
-@router.get("/employees/{employee_id}", response_class=HTMLResponse)
-def employee_detail(
-    employee_id: int,
-    request: Request,
-    db: Session = Depends(get_db),
-    settings: Settings = Depends(get_settings),
-):
-    require_admin(request, settings)
-    employee = db.get(Employee, employee_id)
-    if not employee:
-        return RedirectResponse("/admin/employees", status_code=303)
-    snapshots = [
-        {
-            "captured_display": format_admin_datetime(snapshot.captured_at),
-            "checksum": snapshot.checksum,
-            "parser_version": snapshot.parser_version,
-        }
-        for snapshot in sorted(employee.snapshots, key=lambda item: item.captured_at, reverse=True)[:20]
-    ]
-    return _render(
-        request,
-        "employee_detail.html",
-        {
-            "employee": employee,
-            "employee_view": employee_detail_payload(employee),
-            "snapshots": snapshots,
-            "refresh_status": request.query_params.get("refresh_status"),
-        },
-    )
-
-
-@router.post("/employees/{employee_id}/refresh")
-def refresh_employee_detail(
-    employee_id: int,
-    request: Request,
-    db: Session = Depends(get_db),
-    settings: Settings = Depends(get_settings),
-):
-    require_admin(request, settings)
-    employee = db.get(Employee, employee_id)
-    if not employee:
-        return RedirectResponse("/admin/directory", status_code=303)
-    run = refresh_employee(db, employee, settings)
-    status = "success" if run.status == "completed" else "error"
-    return RedirectResponse(f"/admin/employees/{employee_id}?refresh_status={status}", status_code=303)
-
-
-@router.get("/runs", response_class=HTMLResponse)
-def runs(request: Request, db: Session = Depends(get_db), settings: Settings = Depends(get_settings)):
-    require_admin(request, settings)
-    run_models = db.scalars(select(CrawlRun).order_by(desc(CrawlRun.started_at)).limit(50)).all()
-    items = [run_payload(run) for run in run_models]
-    errors = db.scalars(select(CrawlError).order_by(desc(CrawlError.created_at)).limit(50)).all()
-    return _render(request, "runs.html", {"runs": items, "errors": errors})
-
-
-@router.get("/runs/{run_id}", response_class=HTMLResponse)
-def run_detail(
-    run_id: int,
-    request: Request,
-    db: Session = Depends(get_db),
-    settings: Settings = Depends(get_settings),
-):
-    require_admin(request, settings)
-    run = db.get(CrawlRun, run_id)
-    if not run:
-        return RedirectResponse("/admin/runs", status_code=303)
-    return _render(request, "run_detail.html", {"run": run_detail_payload(db, run)})
-
-
-@router.post("/runs")
-def trigger_run(
-    request: Request,
-    background_tasks: BackgroundTasks,
-    db: Session = Depends(get_db),
-    settings: Settings = Depends(get_settings),
-):
-    require_admin(request, settings)
-    if get_running_run(db):
-        return RedirectResponse("/admin/runs", status_code=303)
-
-    def _crawl() -> None:
-        with SessionLocal() as db:
-            run_crawl_if_idle(db, settings)
-
-    background_tasks.add_task(_crawl)
-    return RedirectResponse("/admin/runs", status_code=303)
-
-
+                "has_academic_degree": has_academic_degree or "",
+                "sort": sort,
+                "direction": direction,
+                "limit": page["limit"],
+                "offset": page["offset"],
+            },
+        },
+    )
+
+
+@router.get("/employees/{employee_id}", response_class=HTMLResponse)
+def employee_detail(
+    employee_id: int,
+    request: Request,
+    db: Session = Depends(get_db),
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    employee = db.get(Employee, employee_id)
+    if not employee:
+        return RedirectResponse("/admin/employees", status_code=303)
+    snapshots = [
+        {
+            "captured_display": format_admin_datetime(snapshot.captured_at),
+            "checksum": snapshot.checksum,
+            "parser_version": snapshot.parser_version,
+        }
+        for snapshot in sorted(employee.snapshots, key=lambda item: item.captured_at, reverse=True)[:20]
+    ]
+    return _render(
+        request,
+        "employee_detail.html",
+        {
+            "employee": employee,
+            "employee_view": employee_detail_payload(employee),
+            "snapshots": snapshots,
+            "refresh_status": request.query_params.get("refresh_status"),
+        },
+    )
+
+
+@router.post("/employees/{employee_id}/refresh")
+def refresh_employee_detail(
+    employee_id: int,
+    request: Request,
+    db: Session = Depends(get_db),
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    employee = db.get(Employee, employee_id)
+    if not employee:
+        return RedirectResponse("/admin/directory", status_code=303)
+    run = refresh_employee(db, employee, settings)
+    status = "success" if run.status == "completed" else "error"
+    return RedirectResponse(f"/admin/employees/{employee_id}?refresh_status={status}", status_code=303)
+
+
+@router.get("/runs", response_class=HTMLResponse)
+def runs(request: Request, db: Session = Depends(get_db), settings: Settings = Depends(get_settings)):
+    require_admin(request, settings)
+    run_models = db.scalars(select(CrawlRun).order_by(desc(CrawlRun.started_at)).limit(50)).all()
+    items = [run_payload(run) for run in run_models]
+    errors = db.scalars(select(CrawlError).order_by(desc(CrawlError.created_at)).limit(50)).all()
+    return _render(request, "runs.html", {"runs": items, "errors": errors})
+
+
+@router.get("/runs/{run_id}", response_class=HTMLResponse)
+def run_detail(
+    run_id: int,
+    request: Request,
+    db: Session = Depends(get_db),
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    run = db.get(CrawlRun, run_id)
+    if not run:
+        return RedirectResponse("/admin/runs", status_code=303)
+    return _render(request, "run_detail.html", {"run": run_detail_payload(db, run)})
+
+
+@router.post("/runs")
+def trigger_run(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    db: Session = Depends(get_db),
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    if get_running_run(db):
+        return RedirectResponse("/admin/runs", status_code=303)
+
+    def _crawl() -> None:
+        with SessionLocal() as db:
+            run_crawl_if_idle(db, settings)
+
+    background_tasks.add_task(_crawl)
+    return RedirectResponse("/admin/runs", status_code=303)
+
+
 @router.post("/crawl-now")
 def crawl_now(
+    request: Request,
+    background_tasks: BackgroundTasks,
+    db: Session = Depends(get_db),
+    settings: Settings = Depends(get_settings),
+):
+    require_admin(request, settings)
+    if get_running_run(db):
+        return RedirectResponse("/admin", status_code=303)
+
+    def _crawl() -> None:
+        with SessionLocal() as db:
+            run_crawl_if_idle(db, settings)
+
+    background_tasks.add_task(_crawl)
+    return RedirectResponse("/admin", status_code=303)
+
+
+@router.post("/dismissed/refresh")
+def refresh_dismissed(
     request: Request,
     background_tasks: BackgroundTasks,
     db: Session = Depends(get_db),
@@ -223,30 +251,30 @@ def crawl_now(
     if get_running_run(db):
         return RedirectResponse("/admin", status_code=303)
 
-    def _crawl() -> None:
+    def _refresh() -> None:
         with SessionLocal() as db:
-            run_crawl_if_idle(db, settings)
+            refresh_dismissed_status(db, settings)
 
-    background_tasks.add_task(_crawl)
+    background_tasks.add_task(_refresh)
     return RedirectResponse("/admin", status_code=303)
 
 
 def _render(request: Request, template: str, context: dict, status_code: int = 200) -> HTMLResponse:
-    payload = {
-        "request": request,
-        "backend_version": BACKEND_VERSION,
-        "frontend_version": FRONTEND_VERSION,
-        **context,
-    }
-    return templates.TemplateResponse(request, template, payload, status_code=status_code)
-
-
-def _parse_date(value: str | None):
-    if not value:
-        return None
-    try:
-        from datetime import date
-
-        return date.fromisoformat(value)
-    except ValueError:
-        return None
+    payload = {
+        "request": request,
+        "backend_version": BACKEND_VERSION,
+        "frontend_version": FRONTEND_VERSION,
+        **context,
+    }
+    return templates.TemplateResponse(request, template, payload, status_code=status_code)
+
+
+def _parse_date(value: str | None):
+    if not value:
+        return None
+    try:
+        from datetime import date
+
+        return date.fromisoformat(value)
+    except ValueError:
+        return None

app/api.py

@@ -28,6 +28,7 @@ def list_employees(
     started_from: date | None = None,
     started_to: date | None = None,
     has_email: bool | None = None,
+    has_academic_degree: bool | None = None,
     sort: str = "full_name",
     direction: str = "asc",
     limit: int = 50,
@@ -43,6 +44,7 @@ def list_employees(
         started_from=started_from,
         started_to=started_to,
         has_email=has_email,
+        has_academic_degree=has_academic_degree,
         sort=sort,
         direction=direction,
         limit=limit,

app/db.py

@@ -37,6 +37,34 @@ def _ensure_runtime_schema() -> None:
         models.EmployeePublication.__table__.create(bind=engine, checkfirst=True)
         inspector = inspect(engine)
         table_names = set(inspector.get_table_names())
+    if "employees" in table_names and "employee_news_links" not in table_names:
+        models.EmployeeNewsLink.__table__.create(bind=engine, checkfirst=True)
+        inspector = inspect(engine)
+        table_names = set(inspector.get_table_names())
+    if "employees" in table_names and "employee_profile_urls" not in table_names:
+        models.EmployeeProfileUrl.__table__.create(bind=engine, checkfirst=True)
+        inspector = inspect(engine)
+    if "employees" in table_names:
+        employee_columns = {column["name"] for column in inspector.get_columns("employees")}
+        missing_columns = []
+        if "profile_unavailable_streak" not in employee_columns:
+            missing_columns.append("profile_unavailable_streak INTEGER NOT NULL DEFAULT 0")
+        if "last_profile_check_at" not in employee_columns:
+            missing_columns.append("last_profile_check_at TIMESTAMPTZ")
+        if "has_academic_degree" not in employee_columns:
+            missing_columns.append("has_academic_degree BOOLEAN NOT NULL DEFAULT FALSE")
+        if missing_columns:
+            with engine.begin() as connection:
+                for column in missing_columns:
+                    connection.execute(text(f"ALTER TABLE employees ADD COLUMN {column}"))
+                if engine.dialect.name == "postgresql":
+                    connection.execute(
+                        text(
+                            "UPDATE employees SET has_academic_degree = "
+                            "COALESCE(current_data::text ~* '(кандидат|доктор).{0,80}наук|ph\\.?[[:space:]]*d\\.?', FALSE)"
+                        )
+                    )
+                connection.execute(text("CREATE INDEX IF NOT EXISTS ix_employees_has_academic_degree ON employees (has_academic_degree)"))
     if "crawl_runs" not in table_names:
         return
     crawl_run_columns = {column["name"] for column in inspector.get_columns("crawl_runs")}

app/main.py

@@ -4,14 +4,12 @@ from fastapi.staticfiles import StaticFiles
 from app.admin import router as admin_router
 from app.api import router as api_router
 from app.db import init_db
-from app.mcp import router as mcp_router
 from app.version import BACKEND_VERSION
 
 app = FastAPI(title="MIEM Employees", version=BACKEND_VERSION)
 app.mount("/static", StaticFiles(directory="app/static"), name="static")
 app.include_router(api_router)
 app.include_router(admin_router)
-app.include_router(mcp_router)
 
 
 @app.on_event("startup")

app/mcp.py

@@ -1,262 +0,0 @@
-import json
-
-from fastapi import APIRouter, Depends, Request
-from sqlalchemy import desc, or_, select
-from sqlalchemy.orm import Session
-
-from app.db import get_db
-from app.models import CrawlRun, Employee, EmployeePublication
-from app.services.admin_data import run_detail_payload
-from app.services.dataset_versions import service_info_payload, sync_employees_payload
-from app.version import BACKEND_VERSION
-
-router = APIRouter(prefix="/mcp")
-PROTOCOL_VERSION = "2024-11-05"
-SERVICE_NAME = "miem-employees"
-
-
-TOOLS = [
-    {
-        "name": "get_service_info",
-        "description": "Return service metadata, supported tools, and current dataset version.",
-        "inputSchema": {"type": "object", "properties": {}},
-    },
-    {
-        "name": "sync_employees",
-        "description": "Synchronize employees by dataset hash. Returns a full snapshot or a delta from client_hash.",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "client_hash": {"type": "string"},
-                "include_data": {"type": "boolean", "default": True},
-            },
-        },
-    },
-    {
-        "name": "search_employees",
-        "description": "Search MIEM employees by name or profile URL.",
-        "inputSchema": {
-            "type": "object",
-            "properties": {
-                "query": {"type": "string"},
-                "status": {"type": "string", "enum": ["active", "dismissed"]},
-                "limit": {"type": "integer", "default": 20},
-            },
-            "required": ["query"],
-        },
-    },
-    {
-        "name": "get_employee",
-        "description": "Get one employee by profile id, profile key, or canonical URL.",
-        "inputSchema": {"type": "object", "properties": {"profile_id_or_url": {"type": "string"}}, "required": ["profile_id_or_url"]},
-    },
-    {
-        "name": "list_employee_publications",
-        "description": (
-            "List employee publications with detailed fields when available: authors, DOI URL, annotation, "
-            "description, citation text, year, publication type, language, status, and HSE Publications URL."
-        ),
-        "inputSchema": {"type": "object", "properties": {"profile_id_or_url": {"type": "string"}}, "required": ["profile_id_or_url"]},
-    },
-    {
-        "name": "list_employee_courses",
-        "description": "List teaching courses parsed from an employee profile.",
-        "inputSchema": {"type": "object", "properties": {"profile_id_or_url": {"type": "string"}}, "required": ["profile_id_or_url"]},
-    },
-    {
-        "name": "get_crawl_status",
-        "description": "Return the latest crawl run status.",
-        "inputSchema": {"type": "object", "properties": {}},
-    },
-    {
-        "name": "get_crawl_run_details",
-        "description": "Return detailed employee changes and errors for one crawl run.",
-        "inputSchema": {
-            "type": "object",
-            "properties": {"run_id": {"type": "integer"}},
-            "required": ["run_id"],
-        },
-    },
-]
-
-
-@router.post("")
-async def mcp_http(
-    request: Request,
-    db: Session = Depends(get_db),
-) -> dict:
-    payload = await request.json()
-    method = payload.get("method")
-    request_id = payload.get("id")
-    params = payload.get("params") or {}
-
-    try:
-        if method == "initialize":
-            result = {
-                "protocolVersion": PROTOCOL_VERSION,
-                "serverInfo": {"name": SERVICE_NAME, "version": BACKEND_VERSION},
-                "capabilities": {"tools": {}},
-            }
-        elif method == "tools/list":
-            result = {"tools": TOOLS}
-        elif method == "tools/call":
-            result = _call_tool(db, params.get("name"), params.get("arguments") or {})
-        else:
-            return {"jsonrpc": "2.0", "id": request_id, "error": {"code": -32601, "message": "Method not found"}}
-        return {"jsonrpc": "2.0", "id": request_id, "result": result}
-    except Exception as exc:
-        return {"jsonrpc": "2.0", "id": request_id, "error": {"code": -32000, "message": str(exc)}}
-
-
-def _call_tool(db: Session, name: str, arguments: dict) -> dict:
-    if name == "get_service_info":
-        return _tool_response(
-            service_info_payload(
-                db,
-                tools=TOOLS,
-                service_name=SERVICE_NAME,
-                backend_version=BACKEND_VERSION,
-                protocol_version=PROTOCOL_VERSION,
-            )
-        )
-    if name == "sync_employees":
-        return _tool_response(
-            sync_employees_payload(
-                db,
-                client_hash=arguments.get("client_hash"),
-                include_data=bool(arguments.get("include_data", True)),
-            )
-        )
-    if name == "search_employees":
-        return _tool_response(_search_employees(db, arguments))
-    if name == "get_employee":
-        employee = _find_employee(db, arguments["profile_id_or_url"])
-        return _tool_response(_employee_payload(employee) if employee else {"error": "not_found"})
-    if name == "list_employee_publications":
-        employee = _find_employee(db, arguments["profile_id_or_url"])
-        return _tool_response(_collect_section_items(employee, "publications"))
-    if name == "list_employee_courses":
-        employee = _find_employee(db, arguments["profile_id_or_url"])
-        return _tool_response(_collect_section_items(employee, "courses_by_year"))
-    if name == "get_crawl_status":
-        run = db.scalar(select(CrawlRun).order_by(desc(CrawlRun.started_at)).limit(1))
-        return _tool_response(_run_payload(run) if run else {"status": "never_run"})
-    if name == "get_crawl_run_details":
-        run = db.get(CrawlRun, int(arguments["run_id"]))
-        return _tool_response(run_detail_payload(db, run) if run else {"error": "not_found"})
-    raise ValueError(f"Unknown tool: {name}")
-
-
-def _search_employees(db: Session, arguments: dict) -> list[dict]:
-    query = arguments.get("query", "")
-    limit = min(int(arguments.get("limit") or 20), 100)
-    stmt = select(Employee)
-    if arguments.get("status"):
-        stmt = stmt.where(Employee.status == arguments["status"])
-    if query:
-        pattern = f"%{query}%"
-        stmt = stmt.where(or_(Employee.full_name.ilike(pattern), Employee.canonical_url.ilike(pattern)))
-    employees = db.scalars(stmt.order_by(Employee.full_name).limit(limit)).all()
-    return [_employee_payload(employee, include_data=False) for employee in employees]
-
-
-def _find_employee(db: Session, value: str) -> Employee | None:
-    pattern = value.strip()
-    stmt = select(Employee).where(
-        or_(
-            Employee.profile_key == pattern,
-            Employee.profile_id == pattern,
-            Employee.canonical_url == pattern,
-            Employee.canonical_url.ilike(f"%{pattern}%"),
-        )
-    )
-    return db.scalar(stmt.limit(1))
-
-
-def _collect_section_items(employee: Employee | None, section_type: str) -> dict:
-    if not employee:
-        return {"items": []}
-    if section_type == "publications":
-        publications = _stored_publications(employee)
-        if publications:
-            return {"employee": _employee_payload(employee, include_data=False), "items": publications}
-    if not employee.current_data:
-        return {"employee": _employee_payload(employee, include_data=False), "items": []}
-    items = []
-    for section in employee.current_data.get("sections") or []:
-        if section.get("type") != section_type:
-            continue
-        if section_type == "publications":
-            items.extend(section.get("publications") or [])
-        elif section_type == "courses_by_year":
-            items.extend(section.get("courses") or [])
-    return {"employee": _employee_payload(employee, include_data=False), "items": items}
-
-
-def _stored_publications(employee: Employee) -> list[dict]:
-    return [_publication_payload(publication) for publication in sorted(employee.publications, key=_publication_sort_key)]
-
-
-def _publication_sort_key(publication: EmployeePublication) -> tuple:
-    return (publication.year or 0, publication.title or "", publication.id)
-
-
-def _publication_payload(publication: EmployeePublication) -> dict:
-    text = publication.citation_text or publication.title
-    payload = {
-        "id": publication.publication_id,
-        "publication_id": publication.publication_id,
-        "title": publication.title,
-        "text": text,
-        "url": publication.url,
-    }
-    optional = {
-        "year": publication.year,
-        "type": publication.publication_type,
-        "publication_type": publication.publication_type,
-        "language": publication.language,
-        "status": publication.status,
-        "doi_url": publication.doi_url,
-        "other_url": publication.other_url,
-        "document_url": publication.document_url,
-        "citation_text": publication.citation_text,
-        "annotation": publication.annotation,
-        "description": publication.description,
-        "authors": publication.authors,
-    }
-    payload.update({key: value for key, value in optional.items() if value not in (None, [], {})})
-    return payload
-
-
-def _employee_payload(employee: Employee, include_data: bool = True) -> dict:
-    payload = {
-        "profile_key": employee.profile_key,
-        "profile_id": employee.profile_id,
-        "full_name": employee.full_name,
-        "status": employee.status,
-        "canonical_url": employee.canonical_url,
-        "last_seen_at": employee.last_seen_at.isoformat() if employee.last_seen_at else None,
-        "dismissed_at": employee.dismissed_at.isoformat() if employee.dismissed_at else None,
-    }
-    if include_data:
-        payload["data"] = employee.current_data
-    return payload
-
-
-def _run_payload(run: CrawlRun) -> dict:
-    return {
-        "id": run.id,
-        "status": run.status,
-        "source_url": run.source_url,
-        "started_at": run.started_at.isoformat() if run.started_at else None,
-        "finished_at": run.finished_at.isoformat() if run.finished_at else None,
-        "found_count": run.found_count,
-        "parsed_count": run.parsed_count,
-        "skipped_count": run.skipped_count,
-        "error_count": run.error_count,
-        "dismissed_count": run.dismissed_count,
-    }
-
-
-def _tool_response(data: object) -> dict:
-    return {"content": [{"type": "text", "text": json.dumps(data, ensure_ascii=False, default=str)}]}

app/models.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 
-from sqlalchemy import DateTime, ForeignKey, Index, Integer, LargeBinary, String, Text, UniqueConstraint
+from sqlalchemy import Boolean, DateTime, ForeignKey, Index, Integer, LargeBinary, String, Text, UniqueConstraint
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from sqlalchemy.types import JSON
@@ -21,6 +21,7 @@ class Employee(Base):
         UniqueConstraint("profile_key", name="uq_employees_profile_key"),
         Index("ix_employees_full_name", "full_name"),
         Index("ix_employees_status", "status"),
+        Index("ix_employees_has_academic_degree", "has_academic_degree"),
     )
 
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
@@ -33,18 +34,39 @@ class Employee(Base):
     first_seen_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
     last_seen_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
     dismissed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    profile_unavailable_streak: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
+    last_profile_check_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     parser_version: Mapped[str | None] = mapped_column(String(32))
     current_data: Mapped[dict | None] = mapped_column(json_type)
+    has_academic_degree: Mapped[bool] = mapped_column(Boolean, default=False, nullable=False)
     current_checksum: Mapped[str | None] = mapped_column(String(64))
     created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
     updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, onupdate=utcnow, nullable=False)
 
     snapshots: Mapped[list["EmployeeSnapshot"]] = relationship(back_populates="employee")
+    profile_urls: Mapped[list["EmployeeProfileUrl"]] = relationship(back_populates="employee", cascade="all, delete-orphan")
     tabs: Mapped[list["ProfileTab"]] = relationship(back_populates="employee", cascade="all, delete-orphan")
     publications: Mapped[list["EmployeePublication"]] = relationship(back_populates="employee", cascade="all, delete-orphan")
+    news_links: Mapped[list["EmployeeNewsLink"]] = relationship(back_populates="employee", cascade="all, delete-orphan")
     crawl_run_changes: Mapped[list["CrawlRunEmployeeChange"]] = relationship(back_populates="employee")
 
 
+class EmployeeProfileUrl(Base):
+    __tablename__ = "employee_profile_urls"
+    __table_args__ = (
+        UniqueConstraint("employee_id", "url", name="uq_employee_profile_urls_employee_url"),
+        Index("ix_employee_profile_urls_employee_id", "employee_id"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    employee_id: Mapped[int] = mapped_column(ForeignKey("employees.id", ondelete="CASCADE"), nullable=False)
+    url: Mapped[str] = mapped_column(Text, nullable=False)
+    first_seen_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
+    last_seen_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
+
+    employee: Mapped[Employee] = relationship(back_populates="profile_urls")
+
+
 class EmployeeSnapshot(Base):
     __tablename__ = "employee_snapshots"
     __table_args__ = (Index("ix_employee_snapshots_employee_id", "employee_id"),)
@@ -97,6 +119,32 @@ class EmployeePublication(Base):
     employee: Mapped[Employee] = relationship(back_populates="publications")
 
 
+class EmployeeNewsLink(Base):
+    __tablename__ = "employee_news_links"
+    __table_args__ = (
+        UniqueConstraint("employee_id", "url", name="uq_employee_news_links_employee_url"),
+        UniqueConstraint("employee_id", "source_hash", name="uq_employee_news_links_employee_source_hash"),
+        Index("ix_employee_news_links_employee_id", "employee_id"),
+        Index("ix_employee_news_links_url", "url"),
+        Index("ix_employee_news_links_published_at", "published_at"),
+        Index("ix_employee_news_links_published_year", "published_year"),
+    )
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    employee_id: Mapped[int] = mapped_column(ForeignKey("employees.id", ondelete="CASCADE"), nullable=False)
+    title: Mapped[str] = mapped_column(Text, nullable=False)
+    url: Mapped[str | None] = mapped_column(Text)
+    summary: Mapped[str | None] = mapped_column(Text)
+    published_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
+    published_year: Mapped[int | None] = mapped_column(Integer)
+    source_hash: Mapped[str] = mapped_column(String(64), nullable=False)
+    raw_data: Mapped[dict | None] = mapped_column(json_type)
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
+    updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, onupdate=utcnow, nullable=False)
+
+    employee: Mapped[Employee] = relationship(back_populates="news_links")
+
+
 class CrawlRun(Base):
     __tablename__ = "crawl_runs"
 
@@ -114,7 +162,6 @@ class CrawlRun(Base):
     message: Mapped[str | None] = mapped_column(Text)
 
     employee_changes: Mapped[list["CrawlRunEmployeeChange"]] = relationship(back_populates="crawl_run")
-    dataset_versions: Mapped[list["DatasetVersion"]] = relationship(back_populates="crawl_run")
 
 
 class CrawlRunEmployeeChange(Base):
@@ -194,42 +241,3 @@ class ParseResourceCache(Base):
     body_snapshot: Mapped[bytes] = mapped_column(LargeBinary, nullable=False)
     parser_version: Mapped[str | None] = mapped_column(String(32))
     fetched_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
-
-
-class DatasetVersion(Base):
-    __tablename__ = "dataset_versions"
-    __table_args__ = (
-        UniqueConstraint("hash", name="uq_dataset_versions_hash"),
-        Index("ix_dataset_versions_created_at", "created_at"),
-    )
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    hash: Mapped[str] = mapped_column(String(64), nullable=False)
-    previous_hash: Mapped[str | None] = mapped_column(String(64))
-    crawl_run_id: Mapped[int | None] = mapped_column(ForeignKey("crawl_runs.id"))
-    employee_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
-    active_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
-    dismissed_count: Mapped[int] = mapped_column(Integer, default=0, nullable=False)
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utcnow, nullable=False)
-
-    crawl_run: Mapped[CrawlRun | None] = relationship(back_populates="dataset_versions")
-    items: Mapped[list["DatasetVersionItem"]] = relationship(back_populates="dataset_version", cascade="all, delete-orphan")
-
-
-class DatasetVersionItem(Base):
-    __tablename__ = "dataset_version_items"
-    __table_args__ = (
-        UniqueConstraint("dataset_version_id", "profile_key", name="uq_dataset_version_items_version_profile"),
-        Index("ix_dataset_version_items_hash", "dataset_version_id"),
-        Index("ix_dataset_version_items_profile_key", "profile_key"),
-    )
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    dataset_version_id: Mapped[int] = mapped_column(ForeignKey("dataset_versions.id"), nullable=False)
-    profile_key: Mapped[str] = mapped_column(String(255), nullable=False)
-    employee_id: Mapped[int | None] = mapped_column(ForeignKey("employees.id"))
-    status: Mapped[str] = mapped_column(String(32), nullable=False)
-    checksum: Mapped[str] = mapped_column(String(64), nullable=False)
-
-    dataset_version: Mapped[DatasetVersion] = relationship(back_populates="items")
-    employee: Mapped[Employee | None] = relationship()

app/parser/profile.py

@@ -1,6 +1,7 @@
 import hashlib
 import json
 import re
+from datetime import datetime, timezone
 from urllib.parse import urljoin
 
 from bs4 import BeautifulSoup, NavigableString, Tag
@@ -101,6 +102,8 @@ def extract_person_header(soup: BeautifulSoup, source_url: str) -> dict:
 def extract_sections(soup: BeautifulSoup, source_url: str) -> list[dict]:
     sections = []
     for h2 in soup.select("h2"):
+        if h2.find_parent(class_="post") or h2.find_parent(attrs={"data-tab": "press_links_news"}):
+            continue
         title = normalize_ws(h2.get_text(" ", strip=True))
         if not title or "расписание занятий" in title.lower():
             continue
@@ -142,6 +145,21 @@ def extract_sections(soup: BeautifulSoup, source_url: str) -> list[dict]:
             if section_type in {"generic", "paragraphs"}:
                 section["type"] = "year_blocks"
         sections.append(section)
+    news_links = _parse_news_links(soup, source_url)
+    if news_links:
+        sections.append(
+            {
+                "title": "В новостях",
+                "slug": "v_novostyah",
+                "type": "news",
+                "raw_text": "",
+                "paragraphs": [],
+                "items": [item["title"] for item in news_links if item.get("title")],
+                "links": [{"text": item["title"], "url": item["url"]} for item in news_links if item.get("title") and item.get("url")],
+                "news_count": len(news_links),
+                "news_links": news_links,
+            }
+        )
     return sections
 
 
@@ -575,6 +593,95 @@ def _parse_vkr_items(nodes: list) -> list[str]:
     return [item for item in dict.fromkeys(items) if item]
 
 
+def _parse_news_links(soup: BeautifulSoup, source_url: str) -> list[dict]:
+    news = []
+    for post in soup.select('[data-tab="press_links_news"] .post'):
+        if not isinstance(post, Tag):
+            continue
+        anchor = post.select_one(".post__content h2 a[href], h2 a[href], a[href]")
+        title = normalize_ws(anchor.get_text(" ", strip=True)) if anchor else ""
+        href = normalize_ws(anchor.get("href")) if anchor else ""
+        summary_node = post.select_one(".post__text")
+        summary = normalize_ws(summary_node.get_text(" ", strip=True)) if summary_node else ""
+        published_at = _parse_post_date(post)
+        if not title and not href:
+            continue
+        item = {
+            "title": title or href,
+            "url": urljoin(source_url, href) if href else None,
+            "summary": summary or None,
+            "published_at": published_at.isoformat() if published_at else None,
+            "published_year": published_at.year if published_at else _int_or_none(normalize_ws(_select_text(post, ".post-meta__year"))),
+            "raw_data": {
+                "title": title or href,
+                "url": href or None,
+                "summary": summary or None,
+                "date_text": normalize_ws(_select_text(post, ".post-meta__date")),
+            },
+        }
+        news.append(item)
+    return _dedupe_news_links(news)
+
+
+def _select_text(node: Tag, selector: str) -> str:
+    selected = node.select_one(selector)
+    return selected.get_text(" ", strip=True) if selected else ""
+
+
+def _parse_post_date(post: Tag) -> datetime | None:
+    day = _int_or_none(normalize_ws(_select_text(post, ".post-meta__day")))
+    month = _month_number(normalize_ws(_select_text(post, ".post-meta__month")))
+    year = _int_or_none(normalize_ws(_select_text(post, ".post-meta__year")))
+    if not day or not month or not year:
+        return None
+    try:
+        return datetime(year, month, day, tzinfo=timezone.utc)
+    except ValueError:
+        return None
+
+
+def _month_number(value: str) -> int | None:
+    lowered = value.lower().strip(".")
+    months = {
+        "янв": 1,
+        "январь": 1,
+        "января": 1,
+        "фев": 2,
+        "февр": 2,
+        "февраль": 2,
+        "февраля": 2,
+        "март": 3,
+        "мар": 3,
+        "марта": 3,
+        "апр": 4,
+        "апрель": 4,
+        "апреля": 4,
+        "май": 5,
+        "мая": 5,
+        "июнь": 6,
+        "июня": 6,
+        "июль": 7,
+        "июля": 7,
+        "авг": 8,
+        "август": 8,
+        "августа": 8,
+        "сент": 9,
+        "сен": 9,
+        "сентябрь": 9,
+        "сентября": 9,
+        "окт": 10,
+        "октябрь": 10,
+        "октября": 10,
+        "нояб": 11,
+        "ноябрь": 11,
+        "ноября": 11,
+        "дек": 12,
+        "декабрь": 12,
+        "декабря": 12,
+    }
+    return months.get(lowered)
+
+
 def _normalize_publication_item(item: dict, current_author_id: str | None = None) -> dict:
     publication_id = str(item.get("id") or "").strip()
     title = _html_to_text(item.get("title"))
@@ -698,6 +805,17 @@ def _dedupe_publications(items: list[dict]) -> list[dict]:
     return unique
 
 
+def _dedupe_news_links(items: list[dict]) -> list[dict]:
+    seen = set()
+    unique = []
+    for item in items:
+        key = item.get("url") or item.get("title")
+        if key and key not in seen:
+            seen.add(key)
+            unique.append(item)
+    return unique
+
+
 def _html_to_text(value: object) -> str:
     return normalize_ws(BeautifulSoup(str(value or ""), "html.parser").get_text(" ", strip=True))
 

app/services/academic_degrees.py

@@ -0,0 +1,33 @@
+import re
+from typing import Any
+
+
+_PATTERN = re.compile(r"\b(?:кандидат|доктор)(?:\s+[\w-]+){0,12}\s+наук\b|\bph\.?\s*d\.?(?!\w)", re.IGNORECASE)
+
+
+def academic_degrees(data: dict[str, Any] | None) -> list[str]:
+    degrees = []
+    seen = set()
+    for section in (data or {}).get("sections") or []:
+        if not isinstance(section, dict) or not re.search(
+            r"образован|степен|academic degree|education", str(section.get("title") or ""), re.IGNORECASE
+        ):
+            continue
+        values = [
+            *(entry.get("text") for entry in section.get("year_entries") or [] if isinstance(entry, dict)),
+            *(section.get("paragraphs") or []),
+            *(section.get("items") or []),
+            section.get("raw_text"),
+        ]
+        table = section.get("table") or {}
+        for row in table.get("rows") or []:
+            if isinstance(row, dict):
+                values.extend(row.get("cells") or [])
+        for value in values:
+            text = str(value or "").strip()
+            for match in _PATTERN.finditer(text):
+                degree = match.group(0).strip()
+                if degree.casefold() not in seen:
+                    seen.add(degree.casefold())
+                    degrees.append(degree)
+    return degrees

app/services/admin_data.py

@@ -8,7 +8,8 @@ from zoneinfo import ZoneInfo
 from sqlalchemy import Select, Text, and_, desc, func, or_, select
 from sqlalchemy.orm import Session
 
-from app.models import CrawlError, CrawlRun, CrawlRunEmployeeChange, Employee
+from app.models import CrawlError, CrawlRun, CrawlRunEmployeeChange, Employee, EmployeeNewsLink
+from app.services.academic_degrees import academic_degrees
 
 EMPLOYEE_SORTS = {
     "full_name": Employee.full_name,
@@ -19,14 +20,15 @@ EMPLOYEE_SORTS = {
     "hse_start_year": Employee.current_data["hse_start_year"].as_integer(),
 }
 
-
 def employee_display_payload(employee: Employee) -> dict[str, Any]:
     data = _as_dict(employee.current_data)
     contacts = _as_dict(data.get("contacts"))
     sections = _as_list(data.get("sections"))
+    stored_news_links = _stored_news_links(employee)
     positions = _clean_list(data.get("positions"))
     emails = _clean_list(contacts.get("emails"))
     phones = _clean_list(contacts.get("phones"))
+    degree_values = academic_degrees(data)
     return {
         "id": employee.id,
         "full_name": employee.full_name,
@@ -41,8 +43,10 @@ def employee_display_payload(employee: Employee) -> dict[str, Any]:
         "phones": phones,
         "phone_text": ", ".join(phones),
         "address": contacts.get("address"),
+        "academic_degree_text": "; ".join(degree_values),
         "publications_count": _count_section_items(sections, "publications"),
         "courses_count": _count_section_items(sections, "courses_by_year"),
+        "news_count": len(stored_news_links) or _count_section_items(sections, "news"),
         "first_seen_at": employee.first_seen_at.isoformat() if employee.first_seen_at else None,
         "last_seen_at": employee.last_seen_at.isoformat() if employee.last_seen_at else None,
         "dismissed_at": employee.dismissed_at.isoformat() if employee.dismissed_at else None,
@@ -67,6 +71,7 @@ def employee_detail_payload(employee: Employee) -> dict[str, Any]:
             "contact_items": _normalize_contact_items(contacts.get("items")),
         },
         "external_ids": _normalize_external_ids(data.get("external_ids")),
+        "news_links": _detail_news_links(employee, data),
         "sections": [_normalize_section(section) for section in _as_list(data.get("sections"))],
     }
 
@@ -78,6 +83,7 @@ def build_employee_query(
     started_from: date | None = None,
     started_to: date | None = None,
     has_email: bool | None = None,
+    has_academic_degree: bool | None = None,
 ) -> Select[tuple[Employee]]:
     stmt = select(Employee)
     filters = []
@@ -94,6 +100,8 @@ def build_employee_query(
         filters.append(Employee.current_data.cast(Text).ilike("%@%"))
     elif has_email is False:
         filters.append(or_(Employee.current_data.is_(None), ~Employee.current_data.cast(Text).ilike("%@%")))
+    if has_academic_degree is not None:
+        filters.append(Employee.has_academic_degree.is_(has_academic_degree))
     if filters:
         stmt = stmt.where(and_(*filters))
     return stmt
@@ -107,6 +115,7 @@ def list_employees_page(
     started_from: date | None = None,
     started_to: date | None = None,
     has_email: bool | None = None,
+    has_academic_degree: bool | None = None,
     sort: str = "full_name",
     direction: str = "asc",
     limit: int = 50,
@@ -120,8 +129,11 @@ def list_employees_page(
         started_from=started_from,
         started_to=started_to,
         has_email=has_email,
+        has_academic_degree=has_academic_degree,
     )
     total = db.scalar(select(func.count()).select_from(base_stmt.subquery())) or 0
+    if offset >= total:
+        offset = 0
     sort_column = EMPLOYEE_SORTS.get(sort, Employee.full_name)
     order = desc(sort_column) if direction == "desc" else sort_column
     employees = db.scalars(base_stmt.order_by(order).limit(limit).offset(offset)).all()
@@ -142,6 +154,10 @@ def stats_payload(db: Session) -> dict[str, Any]:
     return {
         "total": db.scalar(select(func.count()).select_from(Employee)) or 0,
         "active": db.scalar(select(func.count()).select_from(Employee).where(Employee.status == "active")) or 0,
+        "verification_required": db.scalar(
+            select(func.count()).select_from(Employee).where(Employee.status == "verification_required")
+        )
+        or 0,
         "dismissed": db.scalar(select(func.count()).select_from(Employee).where(Employee.status == "dismissed")) or 0,
         "new_in_last_run": latest_run.new_count if latest_run else 0,
         "latest_added": employee_display_payload(latest_added) if latest_added else None,
@@ -185,7 +201,7 @@ def run_detail_payload(db: Session, run: CrawlRun | None) -> dict[str, Any] | No
         .order_by(CrawlRunEmployeeChange.created_at, CrawlRunEmployeeChange.id)
     ).all()
     errors = db.scalars(select(CrawlError).where(CrawlError.crawl_run_id == run.id).order_by(CrawlError.created_at)).all()
-    grouped_changes = {"new": [], "missing_from_source": [], "dismissed": []}
+    grouped_changes = {"new": [], "missing_from_source": [], "verification_required": [], "dismissed": []}
     for change in changes:
         grouped_changes.setdefault(change.change_type, []).append(_change_payload(change))
     return {
@@ -212,7 +228,7 @@ def format_admin_datetime(value: Any) -> str:
 
 
 def _employee_status_display(status: str | None) -> str:
-    labels = {"active": "Работает", "dismissed": "Уволен"}
+    labels = {"active": "Работает", "verification_required": "Требует проверки", "dismissed": "Уволен"}
     return labels.get(status or "", status or "Не указано")
 
 
@@ -276,6 +292,8 @@ def _count_section_items(sections: list[dict[str, Any]], section_type: str) -> i
             total += len(section.get("publications") or section.get("items") or [])
         elif section_type == "courses_by_year":
             total += len(section.get("courses") or [])
+        elif section_type == "news":
+            total += len(section.get("news_links") or section.get("items") or [])
     return total
 
 
@@ -348,6 +366,8 @@ def _normalize_section(section: Any) -> dict[str, Any]:
         "year_entries": _normalize_year_entries(section.get("year_entries")),
         "publications": _normalize_publications(section.get("publications")),
         "publications_count": section.get("publications_count"),
+        "news_links": _normalize_news_links(section.get("news_links")),
+        "news_count": section.get("news_count"),
         "theses": _normalize_theses(section.get("theses")),
         "theses_count": section.get("theses_count"),
         "academic_year": section.get("academic_year"),
@@ -370,6 +390,77 @@ def _normalize_links(items: Any) -> list[dict[str, str | None]]:
     return normalized
 
 
+def _stored_news_links(employee: Employee) -> list[dict[str, Any]]:
+    return [_stored_news_link_payload(item) for item in sorted(employee.news_links, key=_news_link_sort_key)]
+
+
+def _news_link_sort_key(item: EmployeeNewsLink) -> tuple:
+    timestamp = item.published_at.timestamp() if item.published_at else 0
+    return (-timestamp, item.title or "", item.id)
+
+
+def _stored_news_link_payload(item: EmployeeNewsLink) -> dict[str, Any]:
+    return {
+        "title": item.title,
+        "url": item.url,
+        "summary": item.summary,
+        "published_at": item.published_at.isoformat() if item.published_at else None,
+        "published_year": item.published_year,
+        "published_display": format_admin_date(item.published_at) if item.published_at else str(item.published_year or ""),
+    }
+
+
+def _detail_news_links(employee: Employee, data: dict[str, Any]) -> list[dict[str, Any]]:
+    stored = _stored_news_links(employee)
+    if stored:
+        return stored
+    for section in _as_list(data.get("sections")):
+        if isinstance(section, dict) and section.get("type") == "news":
+            return _normalize_news_links(section.get("news_links"))
+    return []
+
+
+def format_admin_date(value: Any) -> str:
+    if not value:
+        return ""
+    if isinstance(value, str):
+        try:
+            value = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        except ValueError:
+            return value
+    if not isinstance(value, datetime):
+        return str(value)
+    if value.tzinfo:
+        value = value.astimezone(ZoneInfo("Europe/Moscow"))
+    return value.strftime("%d.%m.%Y")
+
+
+def _normalize_news_links(items: Any) -> list[dict[str, Any]]:
+    normalized = []
+    if not isinstance(items, list):
+        return normalized
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        title = str(item.get("title") or item.get("url") or "").strip()
+        url = str(item.get("url") or "").strip()
+        summary = str(item.get("summary") or "").strip()
+        published_at = str(item.get("published_at") or "").strip()
+        published_year = item.get("published_year")
+        if title or url:
+            normalized.append(
+                {
+                    "title": title or url,
+                    "url": url or None,
+                    "summary": summary or None,
+                    "published_at": published_at or None,
+                    "published_year": published_year,
+                    "published_display": format_admin_date(published_at) if published_at else str(published_year or ""),
+                }
+            )
+    return normalized
+
+
 def _normalize_year_entries(items: Any) -> list[dict[str, Any]]:
     normalized = []
     if not isinstance(items, list):

app/services/dataset_versions.py

@@ -1,227 +0,0 @@
-import hashlib
-import json
-from dataclasses import dataclass
-
-from sqlalchemy import desc, select
-from sqlalchemy.orm import Session
-
-from app.models import DatasetVersion, DatasetVersionItem, Employee
-
-
-@dataclass(frozen=True)
-class EmployeeMarker:
-    profile_key: str
-    employee_id: int | None
-    status: str
-    checksum: str
-
-
-def get_or_create_current_version(db: Session, *, crawl_run_id: int | None = None) -> DatasetVersion:
-    employees = db.scalars(select(Employee).order_by(Employee.profile_key)).all()
-    markers = [_employee_marker(employee) for employee in employees]
-    dataset_hash = _dataset_hash(markers)
-    latest = get_latest_version(db)
-    if latest and latest.hash == dataset_hash:
-        return latest
-
-    active_count = sum(1 for marker in markers if marker.status == "active")
-    dismissed_count = sum(1 for marker in markers if marker.status == "dismissed")
-    version = DatasetVersion(
-        hash=dataset_hash,
-        previous_hash=latest.hash if latest else None,
-        crawl_run_id=crawl_run_id,
-        employee_count=len(markers),
-        active_count=active_count,
-        dismissed_count=dismissed_count,
-    )
-    db.add(version)
-    db.flush()
-    for marker in markers:
-        db.add(
-            DatasetVersionItem(
-                dataset_version_id=version.id,
-                profile_key=marker.profile_key,
-                employee_id=marker.employee_id,
-                status=marker.status,
-                checksum=marker.checksum,
-            )
-        )
-    db.flush()
-    return version
-
-
-def get_latest_version(db: Session) -> DatasetVersion | None:
-    return db.scalar(select(DatasetVersion).order_by(desc(DatasetVersion.created_at), desc(DatasetVersion.id)).limit(1))
-
-
-def get_version_by_hash(db: Session, dataset_hash: str | None) -> DatasetVersion | None:
-    if not dataset_hash:
-        return None
-    return db.scalar(select(DatasetVersion).where(DatasetVersion.hash == dataset_hash).limit(1))
-
-
-def service_info_payload(db: Session, *, tools: list[dict], service_name: str, backend_version: str, protocol_version: str) -> dict:
-    version = get_or_create_current_version(db)
-    db.commit()
-    return {
-        "service_name": service_name,
-        "backend_version": backend_version,
-        "protocolVersion": protocol_version,
-        "tools": tools,
-        "dataset": _version_payload(version),
-    }
-
-
-def sync_employees_payload(db: Session, *, client_hash: str | None = None, include_data: bool = True) -> dict:
-    current = get_or_create_current_version(db)
-    db.commit()
-    if not client_hash:
-        return _full_sync_payload(db, current, include_data=include_data, reason=None)
-    if client_hash == current.hash:
-        return {
-            "mode": "delta",
-            "from_hash": client_hash,
-            "to_hash": current.hash,
-            "dataset": _version_payload(current),
-            "changes": {"added": [], "updated": [], "dismissed": [], "removed": []},
-        }
-
-    previous = get_version_by_hash(db, client_hash)
-    if not previous:
-        return _full_sync_payload(db, current, include_data=include_data, reason="unknown_client_hash", from_hash=client_hash)
-
-    return _delta_sync_payload(db, previous, current, include_data=include_data)
-
-
-def _full_sync_payload(
-    db: Session,
-    current: DatasetVersion,
-    *,
-    include_data: bool,
-    reason: str | None,
-    from_hash: str | None = None,
-) -> dict:
-    employees = db.scalars(select(Employee).order_by(Employee.profile_key)).all()
-    payload = {
-        "mode": "full",
-        "from_hash": from_hash,
-        "to_hash": current.hash,
-        "dataset": _version_payload(current),
-        "items": [_employee_payload(employee, include_data=include_data) for employee in employees],
-    }
-    if reason:
-        payload["reason"] = reason
-    return payload
-
-
-def _delta_sync_payload(db: Session, previous: DatasetVersion, current: DatasetVersion, *, include_data: bool) -> dict:
-    previous_items = _items_by_profile_key(previous)
-    current_items = _items_by_profile_key(current)
-    employees = {employee.profile_key: employee for employee in db.scalars(select(Employee)).all()}
-    added = []
-    updated = []
-    dismissed = []
-    removed = []
-
-    for profile_key, current_item in sorted(current_items.items()):
-        previous_item = previous_items.get(profile_key)
-        employee = employees.get(profile_key)
-        if not previous_item:
-            if employee:
-                added.append(_employee_payload(employee, include_data=include_data))
-            continue
-        if previous_item.checksum == current_item.checksum and previous_item.status == current_item.status:
-            continue
-        if current_item.status == "dismissed":
-            dismissed.append(_tombstone(profile_key, current_item.status, employee))
-        elif employee:
-            updated.append(_employee_payload(employee, include_data=include_data))
-
-    for profile_key, previous_item in sorted(previous_items.items()):
-        if profile_key not in current_items:
-            removed.append(_tombstone(profile_key, "removed", employees.get(profile_key), checksum=previous_item.checksum))
-
-    return {
-        "mode": "delta",
-        "from_hash": previous.hash,
-        "to_hash": current.hash,
-        "dataset": _version_payload(current),
-        "changes": {
-            "added": added,
-            "updated": updated,
-            "dismissed": dismissed,
-            "removed": removed,
-        },
-    }
-
-
-def _items_by_profile_key(version: DatasetVersion) -> dict[str, DatasetVersionItem]:
-    return {item.profile_key: item for item in version.items}
-
-
-def _version_payload(version: DatasetVersion) -> dict:
-    return {
-        "hash": version.hash,
-        "previous_hash": version.previous_hash,
-        "created_at": version.created_at.isoformat() if version.created_at else None,
-        "crawl_run_id": version.crawl_run_id,
-        "employee_count": version.employee_count,
-        "active_count": version.active_count,
-        "dismissed_count": version.dismissed_count,
-    }
-
-
-def _employee_marker(employee: Employee) -> EmployeeMarker:
-    return EmployeeMarker(
-        profile_key=employee.profile_key,
-        employee_id=employee.id,
-        status=employee.status,
-        checksum=employee.current_checksum or _payload_hash(employee.current_data or {}),
-    )
-
-
-def _dataset_hash(markers: list[EmployeeMarker]) -> str:
-    payload = [
-        {"profile_key": marker.profile_key, "status": marker.status, "checksum": marker.checksum}
-        for marker in sorted(markers, key=lambda item: item.profile_key)
-    ]
-    return _payload_hash(payload)
-
-
-def _payload_hash(value: object) -> str:
-    payload = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), default=str)
-    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
-
-
-def _employee_payload(employee: Employee, *, include_data: bool) -> dict:
-    payload = {
-        "profile_key": employee.profile_key,
-        "profile_id": employee.profile_id,
-        "full_name": employee.full_name,
-        "status": employee.status,
-        "canonical_url": employee.canonical_url,
-        "last_seen_at": employee.last_seen_at.isoformat() if employee.last_seen_at else None,
-        "dismissed_at": employee.dismissed_at.isoformat() if employee.dismissed_at else None,
-        "checksum": employee.current_checksum or _payload_hash(employee.current_data or {}),
-    }
-    if include_data:
-        payload["data"] = employee.current_data
-    return payload
-
-
-def _tombstone(profile_key: str, status: str, employee: Employee | None, *, checksum: str | None = None) -> dict:
-    payload = {
-        "profile_key": profile_key,
-        "status": status,
-        "checksum": checksum or (employee.current_checksum if employee else None),
-    }
-    if employee:
-        payload.update(
-            {
-                "profile_id": employee.profile_id,
-                "full_name": employee.full_name,
-                "canonical_url": employee.canonical_url,
-                "dismissed_at": employee.dismissed_at.isoformat() if employee.dismissed_at else None,
-            }
-        )
-    return payload

app/static/admin.js

@@ -3,13 +3,15 @@
     "full_name",
     "status",
     "positions",
-    "hse_start_year",
-    "email",
     "last_seen_at",
-    "dismissed_at",
     "profile",
   ];
   const storageKey = "miem.directory.columns";
+  const columnPresets = {
+    review: ["full_name", "status", "academic_degree", "last_seen_at", "profile"],
+    contacts: ["full_name", "status", "email", "phone", "address", "profile"],
+    full: ["full_name", "status", "positions", "hse_start_year", "email", "phone", "address", "academic_degree", "publications_count", "courses_count", "news_count", "first_seen_at", "last_seen_at", "dismissed_at", "profile"],
+  };
 
   function readColumns() {
     try {
@@ -39,18 +41,33 @@
     if (!document.querySelector("[data-directory-table]")) return;
     let columns = readColumns();
     const modal = document.querySelector("[data-columns-modal]");
+    const trigger = document.querySelector("[data-columns-open]");
     applyColumns(columns);
 
-    document.querySelectorAll("[data-columns-open]").forEach((button) => {
-      button.addEventListener("click", () => {
-        modal.hidden = false;
-      });
+    trigger.addEventListener("click", () => {
+      modal.showModal();
+      trigger.setAttribute("aria-expanded", "true");
+      modal.querySelector("input")?.focus();
     });
     document.querySelectorAll("[data-columns-close]").forEach((button) => {
       button.addEventListener("click", () => {
-        modal.hidden = true;
+        modal.close();
       });
     });
+    document.querySelectorAll("[data-columns-preset]").forEach((button) => {
+      button.addEventListener("click", () => {
+        columns = columnPresets[button.dataset.columnsPreset];
+        writeColumns(columns);
+        applyColumns(columns);
+      });
+    });
+    modal.addEventListener("click", (event) => {
+      if (event.target === modal) modal.close();
+    });
+    modal.addEventListener("close", () => {
+      trigger.setAttribute("aria-expanded", "false");
+      trigger.focus();
+    });
     document.querySelectorAll("[data-column-toggle]").forEach((checkbox) => {
       checkbox.addEventListener("change", () => {
         columns = Array.from(document.querySelectorAll("[data-column-toggle]:checked")).map((item) => item.value);
@@ -61,28 +78,14 @@
     });
   }
 
-  function setupClickableRows() {
-    const openRow = (row) => {
-      window.location.href = row.dataset.rowHref;
-    };
-
-    document.querySelectorAll("[data-row-href]").forEach((row) => {
-      row.addEventListener("click", (event) => {
-        if (event.target.closest("a, button, input, select, label")) return;
-        openRow(row);
-      });
-      row.addEventListener("keydown", (event) => {
-        if (!["Enter", " "].includes(event.key)) return;
-        if (event.target.closest("a, button, input, select, label")) return;
-        event.preventDefault();
-        openRow(row);
-      });
-    });
-  }
-
   function setupProgress() {
     const panel = document.querySelector("[data-progress-panel]");
     if (!panel) return;
+    const state = document.createElement("p");
+    state.className = "progress-panel__empty";
+    state.setAttribute("role", "status");
+    panel.append(state);
+    let pending = false;
 
     const update = (run) => {
       if (!run) return;
@@ -93,6 +96,7 @@
       const errors = document.querySelector("[data-progress-errors]");
       const fill = document.querySelector("[data-progress-fill]");
       const percent = document.querySelector("[data-progress-percent]");
+      const error = document.querySelector("[data-progress-error]");
       if (status) status.textContent = run.status_display || run.status;
       if (processed) processed.textContent = run.processed_count;
       if (found) found.textContent = run.found_count;
@@ -100,21 +104,44 @@
       if (errors) errors.textContent = run.error_count;
       if (fill) fill.style.width = `${run.progress_percent}%`;
       if (percent) percent.textContent = run.progress_percent;
+      if (fill) {
+        fill.parentElement.setAttribute("aria-valuenow", run.progress_percent);
+        fill.parentElement.setAttribute("aria-valuetext", `${run.progress_percent}%`);
+      }
+      if (error) error.hidden = true;
     };
 
     const poll = async () => {
+      if (pending) return true;
+      pending = true;
+      state.textContent = "Обновляем прогресс…";
+      panel.setAttribute("aria-busy", "true");
       try {
-        const response = await fetch("/api/crawl-runs/latest", { credentials: "same-origin" });
-        if (!response.ok) return false;
+        const response = await fetch("/api/crawl-runs/latest", {
+          credentials: "same-origin",
+          signal: AbortSignal.timeout(15000),
+        });
+        if (!response.ok) throw new Error("progress request failed");
         const data = await response.json();
         const run = data.running || data.latest;
         update(run);
+        state.textContent = run ? "Прогресс обновлён" : "Запусков пока нет. Запустите парсинг.";
+        const error = document.querySelector("[data-progress-error]");
+        if (error) error.hidden = true;
         return Boolean(data.running);
       } catch (_error) {
-        return false;
+        const error = document.querySelector("[data-progress-error]");
+        if (error) error.hidden = false;
+        state.textContent = "Показаны последние полученные данные. Прогресс может быть устаревшим.";
+        return true;
+      } finally {
+        pending = false;
+        panel.setAttribute("aria-busy", "false");
       }
     };
 
+    document.querySelectorAll("[data-progress-retry]").forEach((button) => button.addEventListener("click", poll));
+
     const interval = window.setInterval(async () => {
       const keepGoing = await poll();
       if (!keepGoing) window.clearInterval(interval);
@@ -122,6 +149,5 @@
   }
 
   setupColumns();
-  setupClickableRows();
   setupProgress();
 })();

app/templates/base.html

@@ -7,18 +7,19 @@
     <link rel="stylesheet" href="/static/admin.css">
   </head>
   <body class="admin">
+    <a class="admin__skip-link" href="#main-content">Перейти к содержимому</a>
     <header class="admin__header">
       <h1 class="admin__brand"><a class="admin__brand-link" href="/admin">MIEM Employees</a></h1>
       <nav class="admin__nav">
-        <a class="admin__link" href="/admin">Обзор</a>
-        <a class="admin__link" href="/admin/directory">Сотрудники</a>
-        <a class="admin__link" href="/admin/runs">Запуски</a>
+        <a class="admin__link" href="/admin"{% if request.url.path == "/admin" %} aria-current="page"{% endif %}>Обзор</a>
+        <a class="admin__link" href="/admin/directory"{% if request.url.path == "/admin/directory" %} aria-current="page"{% endif %}>Сотрудники</a>
+        <a class="admin__link" href="/admin/runs"{% if request.url.path.startswith("/admin/runs") %} aria-current="page"{% endif %}>Запуски</a>
         <form method="post" action="/admin/logout">
           <button class="button button--ghost" type="submit">Выйти</button>
         </form>
       </nav>
     </header>
-    <main class="admin__main">
+    <main class="admin__main" id="main-content">
       {% block content %}{% endblock %}
     </main>
     <footer class="admin__footer">

app/templates/dashboard.html

@@ -1,63 +1,70 @@
-{% extends "base.html" %}
-{% block title %}Обзор · MIEM Employees{% endblock %}
-{% block content %}
-<section class="admin__grid">
-  <a class="metric metric--link" href="/admin/directory"><span class="metric__label">Всего в базе</span><span class="metric__value">{{ counts.total }}</span></a>
-  <a class="metric metric--link" href="/admin/directory?status=active"><span class="metric__label">Работают</span><span class="metric__value">{{ counts.active }}</span></a>
-  <a class="metric metric--link" href="{% if latest_run %}/admin/runs/{{ latest_run.id }}#new-employees{% else %}/admin/runs{% endif %}"><span class="metric__label">Новые за запуск</span><span class="metric__value">{{ counts.new_in_last_run }}</span></a>
-  <a class="metric metric--link" href="/admin/directory?status=dismissed"><span class="metric__label">Уволены</span><span class="metric__value">{{ counts.dismissed }}</span></a>
-</section>
-<section class="stats-strip">
-  <div class="stats-strip__item">
-    <span class="stats-strip__label">Последний добавленный</span>
-    {% if counts.latest_added %}
-    <a class="stats-strip__value" href="/admin/employees/{{ counts.latest_added.id }}">{{ counts.latest_added.full_name or counts.latest_added.canonical_url }}</a>
-    {% else %}
-    <span class="stats-strip__value">Сотрудников пока нет</span>
-    {% endif %}
-  </div>
-  <a class="stats-strip__item stats-strip__item--link" href="/admin/runs">
-    <span class="stats-strip__label">Запуски</span>
-    <span class="stats-strip__value">{{ counts.runs }}</span>
-  </a>
-  <div class="stats-strip__item">
-    <span class="stats-strip__label">Ошибки</span>
-    <span class="stats-strip__value">{{ counts.errors }}</span>
-  </div>
-</section>
-<section class="panel progress-panel" data-progress-panel>
-  <div class="progress-panel__header">
-    <h2 class="panel__title">Прогресс парсинга</h2>
-    <form method="post" action="/admin/crawl-now">
-      <button class="button" type="submit">Запустить парсинг</button>
-    </form>
-  </div>
-  {% set run = counts.current_running_run or latest_run %}
-  <div class="progress-panel__body" data-progress-body>
-    <div class="progress-panel__meta">
-      <span data-progress-status>{{ run.status_display if run else "Ожидание" }}</span>
-      <span>обработано: <span data-progress-processed>{{ run.processed_count if run else 0 }}</span> / <span data-progress-found>{{ run.found_count if run else 0 }}</span></span>
-      <span>без изменений: <span data-progress-skipped>{{ run.skipped_count if run else 0 }}</span></span>
-      <span>ошибок: <span data-progress-errors>{{ run.error_count if run else 0 }}</span></span>
-    </div>
-    <div class="progress-bar" aria-label="Parsing progress">
-      <div class="progress-bar__fill" data-progress-fill style="width: {{ run.progress_percent if run else 0 }}%"></div>
-    </div>
-    <div class="progress-panel__percent"><span data-progress-percent>{{ run.progress_percent if run else 0 }}</span>%</div>
-  </div>
-</section>
-<section class="panel">
-  <h2 class="panel__title">Последние запуски</h2>
-  <table class="table">
-    <thead><tr><th class="table__head">ID</th><th class="table__head">Статус</th><th class="table__head">Обработано</th><th class="table__head">Без изменений</th><th class="table__head">Ошибки</th><th class="table__head">Старт</th></tr></thead>
-    <tbody>
-      {% for run in runs %}
-      <tr class="table__row" onclick="window.location.href='/admin/runs/{{ run.id }}'" onkeydown="if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); window.location.href='/admin/runs/{{ run.id }}'; }" role="link" tabindex="0"><td class="table__cell">{{ run.id }}</td><td class="table__cell">{{ run.status_display }}</td><td class="table__cell">{{ run.parsed_count }}</td><td class="table__cell">{{ run.skipped_count }}</td><td class="table__cell">{{ run.error_count }}</td><td class="table__cell">{{ run.started_display }}</td></tr>
-      {% endfor %}
-    </tbody>
-  </table>
-</section>
-{% endblock %}
-{% block scripts %}
-<script src="/static/admin.js"></script>
-{% endblock %}
+{% extends "base.html" %}
+{% block title %}Обзор · MIEM Employees{% endblock %}
+{% block content %}
+<section class="admin__grid">
+  <a class="metric metric--link" href="/admin/directory"><span class="metric__label">Всего в базе</span><span class="metric__value">{{ counts.total }}</span></a>
+  <a class="metric metric--link" href="/admin/directory?status=active"><span class="metric__label">Работают</span><span class="metric__value">{{ counts.active }}</span></a>
+  <a class="metric metric--link" href="/admin/directory?status=verification_required"><span class="metric__label">Требуют проверки</span><span class="metric__value">{{ counts.verification_required }}</span></a>
+  <a class="metric metric--link" href="{% if latest_run %}/admin/runs/{{ latest_run.id }}#new-employees{% else %}/admin/runs{% endif %}"><span class="metric__label">Новые за запуск</span><span class="metric__value">{{ counts.new_in_last_run }}</span></a>
+  <a class="metric metric--link" href="/admin/directory?status=dismissed"><span class="metric__label">Уволены</span><span class="metric__value">{{ counts.dismissed }}</span></a>
+</section>
+<section class="stats-strip">
+  <div class="stats-strip__item">
+    <span class="stats-strip__label">Последний добавленный</span>
+    {% if counts.latest_added %}
+    <a class="stats-strip__value" href="/admin/employees/{{ counts.latest_added.id }}">{{ counts.latest_added.full_name or counts.latest_added.canonical_url }}</a>
+    {% else %}
+    <span class="stats-strip__value">Сотрудников пока нет</span>
+    {% endif %}
+  </div>
+  <a class="stats-strip__item stats-strip__item--link" href="/admin/runs">
+    <span class="stats-strip__label">Запуски</span>
+    <span class="stats-strip__value">{{ counts.runs }}</span>
+  </a>
+  <div class="stats-strip__item">
+    <span class="stats-strip__label">Ошибки</span>
+    <span class="stats-strip__value">{{ counts.errors }}</span>
+  </div>
+</section>
+<section class="panel progress-panel" data-progress-panel>
+  <div class="progress-panel__header">
+    <h2 class="panel__title">Прогресс парсинга</h2>
+    <div class="progress-panel__actions">
+      <form method="post" action="/admin/crawl-now">
+        <button class="button" type="submit">Запустить парсинг</button>
+      </form>
+      <form method="post" action="/admin/dismissed/refresh">
+        <button class="button button--secondary" type="submit">Проверить уволенных</button>
+      </form>
+    </div>
+  </div>
+  {% set run = counts.current_running_run or latest_run %}
+  <div class="progress-panel__body" data-progress-body>
+    <div class="progress-panel__meta">
+      <span data-progress-status>{{ run.status_display if run else "Ожидание" }}</span>
+      <span>обработано: <span data-progress-processed>{{ run.processed_count if run else 0 }}</span> / <span data-progress-found>{{ run.found_count if run else 0 }}</span></span>
+      <span>без изменений: <span data-progress-skipped>{{ run.skipped_count if run else 0 }}</span></span>
+      <span>ошибок: <span data-progress-errors>{{ run.error_count if run else 0 }}</span></span>
+    </div>
+    <div class="progress-bar" role="progressbar" aria-label="Прогресс парсинга" aria-valuemin="0" aria-valuemax="100" aria-valuenow="{{ run.progress_percent if run else 0 }}" aria-valuetext="{{ run.progress_percent if run else 0 }}%">
+      <div class="progress-bar__fill" data-progress-fill style="width: {{ run.progress_percent if run else 0 }}%"></div>
+    </div>
+    <div class="progress-panel__percent"><span data-progress-percent>{{ run.progress_percent if run else 0 }}</span>%</div>
+    <p class="progress-panel__error" data-progress-error role="status" hidden>Не удалось обновить прогресс. <button class="button button--ghost button--compact" type="button" data-progress-retry>Повторить</button></p>
+  </div>
+</section>
+<section class="panel">
+  <h2 class="panel__title">Последние запуски</h2>
+  <table class="table">
+    <thead><tr><th class="table__head">ID</th><th class="table__head">Статус</th><th class="table__head">Обработано</th><th class="table__head">Без изменений</th><th class="table__head">Ошибки</th><th class="table__head">Старт</th></tr></thead>
+    <tbody>
+      {% for run in runs %}
+      <tr class="table__row"><td class="table__cell"><a class="admin__link" href="/admin/runs/{{ run.id }}">{{ run.id }}</a></td><td class="table__cell">{{ run.status_display }}</td><td class="table__cell">{{ run.parsed_count }}</td><td class="table__cell">{{ run.skipped_count }}</td><td class="table__cell">{{ run.error_count }}</td><td class="table__cell">{{ run.started_display }}</td></tr>
+      {% endfor %}
+    </tbody>
+  </table>
+</section>
+{% endblock %}
+{% block scripts %}
+<script src="/static/admin.js"></script>
+{% endblock %}

app/templates/directory.html

@@ -5,43 +5,70 @@
   <div class="directory__header">
     <div>
       <h2 class="directory__title">Сотрудники</h2>
-      <p class="directory__summary">Найдено: {{ page.total }}</p>
+      {% set range_start = page.offset + 1 if page.total else 0 %}
+      {% set range_end = [page.offset + page.employees|length, page.total]|min %}
+      <p class="directory__summary" role="status">Показаны {{ range_start }}–{{ range_end }} из {{ page.total }}</p>
     </div>
-    <button class="button" type="button" data-columns-open>Колонки</button>
+    <button class="button" type="button" data-columns-open aria-controls="columns-dialog" aria-expanded="false">Настроить колонки</button>
   </div>
 
   <form class="directory__filters" method="get" action="/admin/directory">
-    <input class="directory__input" name="q" value="{{ filters.q }}" placeholder="ФИО или ссылка">
-    <select class="directory__input" name="status">
+    <fieldset class="directory__filter-group directory__filter-group--search">
+      <legend class="directory__filter-legend">Поиск</legend>
+      <label class="directory__field">ФИО или ссылка<input class="directory__input" name="q" value="{{ filters.q }}" placeholder="Например, Иванов или hse.ru"></label>
+    </fieldset>
+    <fieldset class="directory__filter-group">
+      <legend class="directory__filter-legend">Статус и данные</legend>
+      <label class="directory__field">Статус<select class="directory__input" name="status">
       <option value="" {% if not filters.status %}selected{% endif %}>Все статусы</option>
       <option value="active" {% if filters.status == "active" %}selected{% endif %}>Работает</option>
+      <option value="verification_required" {% if filters.status == "verification_required" %}selected{% endif %}>Требует проверки</option>
       <option value="dismissed" {% if filters.status == "dismissed" %}selected{% endif %}>Уволен</option>
-    </select>
-    <select class="directory__input" name="has_email">
+      </select></label>
+      <label class="directory__field">Email<select class="directory__input" name="has_email">
       <option value="" {% if not filters.has_email %}selected{% endif %}>Любой email</option>
       <option value="true" {% if filters.has_email == "true" %}selected{% endif %}>Есть email</option>
       <option value="false" {% if filters.has_email == "false" %}selected{% endif %}>Нет email</option>
-    </select>
-    <input class="directory__input" type="date" name="started_from" value="{{ filters.started_from }}" aria-label="Впервые найден с">
-    <input class="directory__input" type="date" name="started_to" value="{{ filters.started_to }}" aria-label="Впервые найден по">
-    <select class="directory__input" name="sort">
+      </select></label>
+      <label class="directory__field">Учёная степень<select class="directory__input" name="has_academic_degree">
+      <option value="" {% if not filters.has_academic_degree %}selected{% endif %}>Любая учёная степень</option>
+      <option value="true" {% if filters.has_academic_degree == "true" %}selected{% endif %}>Есть учёная степень</option>
+      <option value="false" {% if filters.has_academic_degree == "false" %}selected{% endif %}>Нет учёной степени</option>
+      </select></label>
+    </fieldset>
+    <fieldset class="directory__filter-group">
+      <legend class="directory__filter-legend">Период обнаружения</legend>
+      <label class="directory__field">От<input class="directory__input" type="date" name="started_from" value="{{ filters.started_from }}"></label>
+      <label class="directory__field">До<input class="directory__input" type="date" name="started_to" value="{{ filters.started_to }}"></label>
+    </fieldset>
+    <fieldset class="directory__filter-group">
+      <legend class="directory__filter-legend">Сортировка и страница</legend>
+      <label class="directory__field">Сортировать по<select class="directory__input" name="sort">
       {% for value, label in [("full_name", "ФИО"), ("status", "Статус"), ("hse_start_year", "Год начала"), ("first_seen_at", "Впервые найден"), ("last_seen_at", "Последний раз найден"), ("dismissed_at", "Дата увольнения")] %}
-      <option value="{{ value }}" {% if filters.sort == value %}selected{% endif %}>Сортировка: {{ label }}</option>
+      <option value="{{ value }}" {% if filters.sort == value %}selected{% endif %}>{{ label }}</option>
       {% endfor %}
-    </select>
-    <select class="directory__input" name="direction">
+      </select></label>
+      <label class="directory__field">Направление<select class="directory__input" name="direction">
       <option value="asc" {% if filters.direction == "asc" %}selected{% endif %}>По возрастанию</option>
       <option value="desc" {% if filters.direction == "desc" %}selected{% endif %}>По убыванию</option>
-    </select>
-    <select class="directory__input" name="limit" onchange="this.form.offset.value = 0; this.form.submit()">
+      </select></label>
+      <label class="directory__field">Сотрудников на странице<select class="directory__input" name="limit">
       {% for value in [25, 50, 100] %}
-      <option value="{{ value }}" {% if filters.limit == value %}selected{% endif %}>На странице: {{ value }}</option>
+      <option value="{{ value }}" {% if filters.limit == value %}selected{% endif %}>{{ value }}</option>
       {% endfor %}
-    </select>
-    <input type="hidden" name="offset" value="{{ filters.offset }}">
-    <button class="button" type="submit">Применить</button>
+      </select></label>
+    </fieldset>
+    <div class="directory__filter-actions">
+      <button class="button" type="submit">Применить фильтры</button>
+      <a class="button button--ghost" href="/admin/directory">Сбросить</a>
+    </div>
   </form>
 
+  <details class="directory__help">
+    <summary>Что означают даты и статусы</summary>
+    <p>«Год начала» — начало работы в ВШЭ. «Впервые найден» и «Последний раз найден» — даты обнаружения сотрудника в списке источника, а не даты приёма и увольнения. «Требует проверки» означает, что профиль недоступен и увольнение ещё не подтверждено.</p>
+  </details>
+
   <div class="directory__table-wrap">
     <table class="directory-table" data-directory-table>
       <thead>
@@ -53,8 +80,10 @@
           <th class="directory-table__head" data-column="email">Email</th>
           <th class="directory-table__head" data-column="phone">Телефон</th>
           <th class="directory-table__head" data-column="address">Адрес</th>
+          <th class="directory-table__head" data-column="academic_degree">Учёная степень</th>
           <th class="directory-table__head" data-column="publications_count">Публикации</th>
           <th class="directory-table__head" data-column="courses_count">Курсы</th>
+          <th class="directory-table__head" data-column="news_count">Новости</th>
           <th class="directory-table__head" data-column="first_seen_at">Впервые найден</th>
           <th class="directory-table__head" data-column="last_seen_at">Последний раз найден</th>
           <th class="directory-table__head" data-column="dismissed_at">Дата увольнения</th>
@@ -63,23 +92,33 @@
       </thead>
       <tbody>
         {% for employee in page.employees %}
-        <tr class="directory-table__row" data-row-href="/admin/employees/{{ employee.id }}">
-          <td class="directory-table__cell" data-column="full_name">{{ employee.full_name or "Без имени" }}</td>
-          <td class="directory-table__cell" data-column="status"><span class="badge {% if employee.status == "dismissed" %}badge--dismissed{% endif %}">{{ employee.status_display }}</span></td>
+        <tr class="directory-table__row">
+          <td class="directory-table__cell" data-column="full_name"><a class="admin__link" href="/admin/employees/{{ employee.id }}">{{ employee.full_name or "Без имени" }}</a></td>
+          <td class="directory-table__cell" data-column="status"><span class="badge {% if employee.status == "dismissed" %}badge--dismissed{% elif employee.status == "verification_required" %}badge--verification{% endif %}">{{ employee.status_display }}</span></td>
           <td class="directory-table__cell" data-column="positions">{{ employee.positions_text }}</td>
           <td class="directory-table__cell" data-column="hse_start_year">{{ employee.hse_start_year or "" }}</td>
           <td class="directory-table__cell" data-column="email">{{ employee.email_text }}</td>
           <td class="directory-table__cell" data-column="phone">{{ employee.phone_text }}</td>
           <td class="directory-table__cell" data-column="address">{{ employee.address or "" }}</td>
+          <td class="directory-table__cell" data-column="academic_degree">{{ employee.academic_degree_text }}</td>
           <td class="directory-table__cell" data-column="publications_count">{{ employee.publications_count }}</td>
           <td class="directory-table__cell" data-column="courses_count">{{ employee.courses_count }}</td>
+          <td class="directory-table__cell" data-column="news_count">{{ employee.news_count }}</td>
           <td class="directory-table__cell" data-column="first_seen_at">{{ employee.first_seen_display }}</td>
           <td class="directory-table__cell" data-column="last_seen_at">{{ employee.last_seen_display }}</td>
           <td class="directory-table__cell" data-column="dismissed_at">{{ employee.dismissed_display }}</td>
-          <td class="directory-table__cell" data-column="profile"><a class="admin__link" href="{{ employee.canonical_url }}">Открыть</a></td>
+          <td class="directory-table__cell" data-column="profile"><a class="admin__link" href="{{ employee.canonical_url }}" target="_blank" rel="noopener">Внешний профиль</a></td>
         </tr>
         {% else %}
-        <tr><td class="directory-table__empty" colspan="13">По этим фильтрам сотрудники не найдены.</td></tr>
+        <tr><td class="directory-table__empty" colspan="15">
+          <strong>Сотрудники не найдены</strong>
+          {% if filters.q or filters.status or filters.has_email or filters.has_academic_degree or filters.started_from or filters.started_to %}
+          <span>Попробуйте изменить запрос или сбросить фильтры.</span>
+          <a class="admin__link" href="/admin/directory">Сбросить фильтры</a>
+          {% else %}
+          <span>Запустите парсинг, чтобы загрузить сотрудников.</span>
+          {% endif %}
+        </td></tr>
         {% endfor %}
       </tbody>
     </table>
@@ -98,20 +137,25 @@
   </div>
 </section>
 
-<div class="columns-modal" data-columns-modal hidden>
-  <div class="columns-modal__backdrop" data-columns-close></div>
-  <section class="columns-modal__panel" aria-label="Настройка колонок">
+<dialog class="columns-modal" id="columns-dialog" data-columns-modal aria-labelledby="columns-dialog-title">
+  <section class="columns-modal__panel">
     <div class="columns-modal__header">
-      <h3 class="columns-modal__title">Отображаемые колонки</h3>
+      <h3 class="columns-modal__title" id="columns-dialog-title">Отображаемые колонки</h3>
       <button class="button button--ghost" type="button" data-columns-close>Закрыть</button>
     </div>
     <div class="columns-modal__grid">
-      {% for key, label in [("full_name", "ФИО"), ("status", "Статус"), ("positions", "Должности"), ("hse_start_year", "Год начала"), ("email", "Email"), ("phone", "Телефон"), ("address", "Адрес"), ("publications_count", "Публикации"), ("courses_count", "Курсы"), ("first_seen_at", "Впервые найден"), ("last_seen_at", "Последний раз найден"), ("dismissed_at", "Дата увольнения"), ("profile", "Профиль")] %}
+      {% for key, label in [("full_name", "ФИО"), ("status", "Статус"), ("positions", "Должности"), ("hse_start_year", "Год начала"), ("email", "Email"), ("phone", "Телефон"), ("address", "Адрес"), ("academic_degree", "Учёная степень"), ("publications_count", "Публикации"), ("courses_count", "Курсы"), ("news_count", "Новости"), ("first_seen_at", "Впервые найден"), ("last_seen_at", "Последний раз найден"), ("dismissed_at", "Дата увольнения"), ("profile", "Профиль")] %}
       <label class="columns-modal__option"><input class="columns-modal__checkbox" type="checkbox" value="{{ key }}" data-column-toggle> {{ label }}</label>
       {% endfor %}
     </div>
+    <fieldset class="columns-modal__presets">
+      <legend class="columns-modal__preset-label">Быстрый набор</legend>
+      <button class="button button--ghost button--compact" type="button" data-columns-preset="review">Проверка</button>
+      <button class="button button--ghost button--compact" type="button" data-columns-preset="contacts">Контакты</button>
+      <button class="button button--ghost button--compact" type="button" data-columns-preset="full">Все поля</button>
+    </fieldset>
   </section>
-</div>
+</dialog>
 {% endblock %}
 {% block scripts %}
 <script src="/static/admin.js"></script>

app/templates/directory_error.html

@@ -0,0 +1,9 @@
+{% extends "base.html" %}
+{% block title %}Каталог недоступен · MIEM Employees{% endblock %}
+{% block content %}
+<section class="panel">
+  <h2 class="panel__title">Не удалось загрузить сотрудников</h2>
+  <p>База данных временно недоступна. Повторите запрос; выбранные фильтры сохранятся.</p>
+  <a class="button" href="{{ request.url.path }}{% if request.url.query %}?{{ request.url.query }}{% endif %}">Повторить загрузку</a>
+</section>
+{% endblock %}

app/templates/employee_detail.html

@@ -104,6 +104,25 @@
   </section>
   {% endif %}
 
+  {% if employee_view.news_links %}
+  <section class="employee-card__section">
+    <h3 class="employee-section__title">В новостях</h3>
+    <ul class="employee-card__list">
+      {% for news in employee_view.news_links %}
+      <li class="employee-card__list-item">
+        {% if news.published_display %}<div class="employee-section__meta"><span class="employee-section__meta-item">{{ news.published_display }}</span></div>{% endif %}
+        {% if news.url %}
+        <a class="admin__link" href="{{ news.url }}">{{ news.title }}</a>
+        {% else %}
+        {{ news.title }}
+        {% endif %}
+        {% if news.summary %}<div class="employee-section__text">{{ news.summary }}</div>{% endif %}
+      </li>
+      {% endfor %}
+    </ul>
+  </section>
+  {% endif %}
+
   <section class="employee-card__section">
     <h3 class="employee-section__title">Разделы профиля</h3>
     {% if employee_view.sections %}

app/templates/run_detail.html

@@ -23,7 +23,7 @@
   {% endif %}
 </section>
 
-{% for group, title in [("new", "Новые сотрудники"), ("missing_from_source", "Потеряшки"), ("dismissed", "Уволенные")] %}
+{% for group, title in [("new", "Новые сотрудники"), ("missing_from_source", "Потеряшки"), ("verification_required", "Требуют проверки"), ("dismissed", "Уволенные")] %}
 <section class="panel"{% if group == "new" %} id="new-employees"{% endif %}>
   <h2 class="panel__title">{{ title }}</h2>
   {% set items = run.changes[group] %}

app/templates/runs.html

@@ -17,10 +17,11 @@
       <span>без изменений: <span data-progress-skipped>{{ run.skipped_count }}</span></span>
       <span>ошибок: <span data-progress-errors>{{ run.error_count }}</span></span>
     </div>
-    <div class="progress-bar" aria-label="Parsing progress">
+    <div class="progress-bar" role="progressbar" aria-label="Прогресс парсинга" aria-valuemin="0" aria-valuemax="100" aria-valuenow="{{ percent }}" aria-valuetext="{{ percent }}%">
       <div class="progress-bar__fill" data-progress-fill style="width: {{ percent }}%"></div>
     </div>
   <div class="progress-panel__percent"><span data-progress-percent>{{ percent }}</span>%</div>
+  <p class="progress-panel__error" data-progress-error role="status" hidden>Не удалось обновить прогресс. <button class="button button--ghost button--compact" type="button" data-progress-retry>Повторить</button></p>
   </div>
   {% else %}
   <div class="progress-panel" data-progress-panel>
@@ -30,17 +31,18 @@
       <span>без изменений: <span data-progress-skipped>0</span></span>
       <span>ошибок: <span data-progress-errors>0</span></span>
     </div>
-    <div class="progress-bar" aria-label="Parsing progress">
+    <div class="progress-bar" role="progressbar" aria-label="Прогресс парсинга" aria-valuemin="0" aria-valuemax="100" aria-valuenow="0" aria-valuetext="0%">
       <div class="progress-bar__fill" data-progress-fill style="width: 0%"></div>
     </div>
     <div class="progress-panel__percent"><span data-progress-percent>0</span>%</div>
+    <p class="progress-panel__error" data-progress-error role="status" hidden>Не удалось обновить прогресс. <button class="button button--ghost button--compact" type="button" data-progress-retry>Повторить</button></p>
   </div>
   {% endif %}
   <table class="table">
     <thead><tr><th class="table__head">ID</th><th class="table__head">Статус</th><th class="table__head">Найдено</th><th class="table__head">Обработано</th><th class="table__head">Без изменений</th><th class="table__head">Новые</th><th class="table__head">Ошибки</th><th class="table__head">Уволены</th><th class="table__head">Старт</th></tr></thead>
     <tbody>
       {% for run in runs %}
-      <tr class="table__row" onclick="window.location.href='/admin/runs/{{ run.id }}'" onkeydown="if (event.key === 'Enter' || event.key === ' ') { event.preventDefault(); window.location.href='/admin/runs/{{ run.id }}'; }" role="link" tabindex="0"><td class="table__cell">{{ run.id }}</td><td class="table__cell">{{ run.status_display }}</td><td class="table__cell">{{ run.found_count }}</td><td class="table__cell">{{ run.parsed_count }}</td><td class="table__cell">{{ run.skipped_count }}</td><td class="table__cell">{{ run.new_count }}</td><td class="table__cell">{{ run.error_count }}</td><td class="table__cell">{{ run.dismissed_count }}</td><td class="table__cell">{{ run.started_display }}</td></tr>
+      <tr class="table__row"><td class="table__cell"><a class="admin__link" href="/admin/runs/{{ run.id }}">{{ run.id }}</a></td><td class="table__cell">{{ run.status_display }}</td><td class="table__cell">{{ run.found_count }}</td><td class="table__cell">{{ run.parsed_count }}</td><td class="table__cell">{{ run.skipped_count }}</td><td class="table__cell">{{ run.new_count }}</td><td class="table__cell">{{ run.error_count }}</td><td class="table__cell">{{ run.dismissed_count }}</td><td class="table__cell">{{ run.started_display }}</td></tr>
       {% endfor %}
     </tbody>
   </table>

app/version.py

@@ -1,3 +1,3 @@
-APP_VERSION = "0.6.2"
-FRONTEND_VERSION = "0.6.2"
-BACKEND_VERSION = "0.6.2"
+APP_VERSION = "0.8.1"
+FRONTEND_VERSION = "0.8.1"
+BACKEND_VERSION = "0.8.1"

docker-compose.yml

@@ -35,17 +35,5 @@ services:
       postgres:
         condition: service_healthy
 
-  mcp:
-    build: .
-    command: uvicorn app.main:app --host 0.0.0.0 --port 8000
-    env_file: .env
-    environment:
-      DATABASE_URL: postgresql+psycopg://${POSTGRES_USER:-miem}:${POSTGRES_PASSWORD:-miem_password}@postgres:5432/${POSTGRES_DB:-miem_workers}
-    ports:
-      - "127.0.0.1:${MCP_PORT:-8001}:8000"
-    depends_on:
-      postgres:
-        condition: service_healthy
-
 volumes:
   postgres_data:

migrations/001_init.sql

@@ -33,6 +33,7 @@ CREATE TABLE IF NOT EXISTS employees (
   dismissed_at TIMESTAMPTZ,
   parser_version VARCHAR(32),
   current_data JSONB,
+  has_academic_degree BOOLEAN NOT NULL DEFAULT FALSE,
   current_checksum VARCHAR(64),
   created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
   updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
@@ -40,6 +41,7 @@ CREATE TABLE IF NOT EXISTS employees (
 
 CREATE INDEX IF NOT EXISTS ix_employees_full_name ON employees (full_name);
 CREATE INDEX IF NOT EXISTS ix_employees_status ON employees (status);
+CREATE INDEX IF NOT EXISTS ix_employees_has_academic_degree ON employees (has_academic_degree);
 
 CREATE TABLE IF NOT EXISTS employee_snapshots (
   id SERIAL PRIMARY KEY,

migrations/007_employee_news_links.sql

@@ -0,0 +1,27 @@
+CREATE TABLE IF NOT EXISTS employee_news_links (
+  id SERIAL PRIMARY KEY,
+  employee_id INTEGER NOT NULL REFERENCES employees(id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  url TEXT,
+  summary TEXT,
+  published_at TIMESTAMPTZ,
+  published_year INTEGER,
+  source_hash VARCHAR(64) NOT NULL,
+  raw_data JSONB,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  CONSTRAINT uq_employee_news_links_employee_url UNIQUE (employee_id, url),
+  CONSTRAINT uq_employee_news_links_employee_source_hash UNIQUE (employee_id, source_hash)
+);
+
+CREATE INDEX IF NOT EXISTS ix_employee_news_links_employee_id
+  ON employee_news_links (employee_id);
+
+CREATE INDEX IF NOT EXISTS ix_employee_news_links_url
+  ON employee_news_links (url);
+
+CREATE INDEX IF NOT EXISTS ix_employee_news_links_published_at
+  ON employee_news_links (published_at);
+
+CREATE INDEX IF NOT EXISTS ix_employee_news_links_published_year
+  ON employee_news_links (published_year);

migrations/008_profile_verification.sql

@@ -0,0 +1,17 @@
+ALTER TABLE employees
+ADD COLUMN IF NOT EXISTS profile_unavailable_streak INTEGER NOT NULL DEFAULT 0;
+
+ALTER TABLE employees
+ADD COLUMN IF NOT EXISTS last_profile_check_at TIMESTAMPTZ;
+
+CREATE TABLE IF NOT EXISTS employee_profile_urls (
+  id SERIAL PRIMARY KEY,
+  employee_id INTEGER NOT NULL REFERENCES employees(id) ON DELETE CASCADE,
+  url TEXT NOT NULL,
+  first_seen_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  last_seen_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+  CONSTRAINT uq_employee_profile_urls_employee_url UNIQUE (employee_id, url)
+);
+
+CREATE INDEX IF NOT EXISTS ix_employee_profile_urls_employee_id
+  ON employee_profile_urls (employee_id);

migrations/009_academic_degree_filter.sql

@@ -0,0 +1,11 @@
+ALTER TABLE employees
+ADD COLUMN IF NOT EXISTS has_academic_degree BOOLEAN NOT NULL DEFAULT FALSE;
+
+UPDATE employees
+SET has_academic_degree = COALESCE(
+  current_data::text ~* '(кандидат|доктор).{0,80}наук|ph\.?[[:space:]]*d\.?',
+  FALSE
+);
+
+CREATE INDEX IF NOT EXISTS ix_employees_has_academic_degree
+  ON employees (has_academic_degree);

pyproject.toml

@@ -1,28 +1,28 @@
-[project]
-name = "miem-workers"
-version = "0.6.2"
-description = "MIEM employees parser, admin API, and MCP server"
-requires-python = ">=3.11"
-dependencies = [
-  "apscheduler>=3.10.4",
-  "beautifulsoup4>=4.12.3",
-  "fastapi>=0.115.0",
-  "httpx>=0.27.0",
-  "jinja2>=3.1.4",
-  "lxml>=5.2.0",
-  "psycopg[binary]>=3.2.0",
-  "pydantic-settings>=2.4.0",
-  "python-multipart>=0.0.9",
-  "requests>=2.32.0",
-  "sqlalchemy>=2.0.32",
-  "uvicorn[standard]>=0.30.0",
-]
-
-[project.optional-dependencies]
-dev = [
-  "pytest>=8.3.0",
-]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-pythonpath = ["."]
+[project]
+name = "miem-workers"
+version = "0.8.1"
+description = "MIEM employees parser, admin API, and web admin"
+requires-python = ">=3.11"
+dependencies = [
+  "apscheduler>=3.10.4",
+  "beautifulsoup4>=4.12.3",
+  "fastapi>=0.115.0",
+  "httpx>=0.27.0",
+  "jinja2>=3.1.4",
+  "lxml>=5.2.0",
+  "psycopg[binary]>=3.2.0",
+  "pydantic-settings>=2.4.0",
+  "python-multipart>=0.0.9",
+  "requests>=2.32.0",
+  "sqlalchemy>=2.0.32",
+  "uvicorn[standard]>=0.30.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.3.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["."]

tests/browser_admin.py

@@ -0,0 +1,126 @@
+"""Run from the repository root: python tests/browser_admin.py.
+
+Requires Playwright and Chromium. Uses in-memory data and intercepted requests;
+never contacts the production service. Optional BROWSER_EXECUTABLE selects an
+already installed Chromium instead of the Playwright download.
+"""
+import os
+from pathlib import Path
+import sys
+from tempfile import mkdtemp
+from urllib.parse import urlsplit
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from fastapi.testclient import TestClient
+from playwright.sync_api import expect, sync_playwright
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+
+from app.config import Settings, get_settings
+from app.db import Base, get_db
+from app.main import app
+from app.models import Employee
+from app.security import SESSION_COOKIE, sign_session
+
+
+def main():
+    engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    factory = sessionmaker(bind=engine)
+    with factory() as db:
+        db.add_all(Employee(profile_key=f"staff:{i}", canonical_url=f"https://www.hse.ru/staff/{i}",
+                            full_name=f"Сотрудник {i:02d}", current_data={"positions": ["Преподаватель"]})
+                   for i in range(30))
+        db.commit()
+
+    def database():
+        with factory() as db:
+            yield db
+
+    settings = Settings(_env_file=None, session_secret="browser-test-secret")
+    app.dependency_overrides[get_db] = database
+    app.dependency_overrides[get_settings] = lambda: settings
+    client = TestClient(app)
+    client.cookies.set(SESSION_COOKIE, sign_session(settings.admin_username, settings))
+    output = Path(mkdtemp(prefix="miem-admin-browser-"))
+    pending = []
+
+    def serve(route):
+        url = urlsplit(route.request.url)
+        if url.path == "/api/crawl-runs/latest":
+            pending.append(route)
+            return
+        response = client.get(url.path + ("?" + url.query if url.query else ""))
+        route.fulfill(status=response.status_code, body=response.content,
+                      content_type=response.headers.get("content-type", "text/plain"))
+
+    try:
+        with sync_playwright() as playwright:
+            browser = playwright.chromium.launch(executable_path=os.getenv("BROWSER_EXECUTABLE"))
+            page = browser.new_page(viewport={"width": 1440, "height": 1000})
+            page.route("**/*", serve)
+            errors = []
+            page.on("pageerror", lambda error: errors.append(str(error)))
+            page.goto("http://miem.test/admin/directory?limit=25&offset=25")
+            expect(page.get_by_role("status")).to_have_text("Показаны 26–30 из 30")
+            assert page.locator("th:visible").count() == 5
+            assert page.locator(".directory__table-wrap").evaluate("e => e.scrollWidth <= e.clientWidth")
+            page.get_by_label("ФИО или ссылка").fill("Сотрудник 00")
+            page.get_by_role("button", name="Применить фильтры").click()
+            expect(page.get_by_role("status")).to_have_text("Показаны 1–1 из 1")
+            assert "offset=" not in page.url
+            trigger = page.get_by_role("button", name="Настроить колонки")
+            trigger.focus()
+            page.keyboard.press("Enter")
+            dialog = page.get_by_role("dialog", name="Отображаемые колонки")
+            expect(dialog).to_be_visible()
+            for _ in range(22):
+                page.keyboard.press("Tab")
+                # Native dialogs may let Tab reach browser chrome, never background controls.
+                assert dialog.evaluate("e => document.activeElement === document.body || e.contains(document.activeElement)")
+            page.keyboard.press("Escape")
+            expect(trigger).to_be_focused()
+            trigger.click()
+            page.get_by_role("button", name="Контакты", exact=True).click()
+            page.keyboard.press("Escape")
+            page.reload()
+            expect(page.locator('th[data-column="email"]')).to_be_visible()
+            page.evaluate("localStorage.clear()")
+            page.goto("http://miem.test/admin/directory")
+            page.screenshot(path=str(output / "desktop.png"), full_page=True)
+            page.set_viewport_size({"width": 390, "height": 844})
+            assert page.evaluate("document.documentElement.scrollWidth <= innerWidth")
+            assert page.locator('th[data-column="full_name"]').evaluate("e => getComputedStyle(e).position") == "sticky"
+            page.screenshot(path=str(output / "mobile.png"), full_page=True)
+            trigger.click()
+            expect(dialog).to_be_visible()
+            assert dialog.evaluate("e => e.getBoundingClientRect().right <= innerWidth")
+            page.screenshot(path=str(output / "mobile-dialog.png"), full_page=True)
+            page.keyboard.press("Escape")
+            page.get_by_label("ФИО или ссылка").fill("Нет совпадений")
+            page.get_by_role("button", name="Применить фильтры").click()
+            expect(page.get_by_text("Сотрудники не найдены", exact=True)).to_be_visible()
+            expect(page.get_by_role("link", name="Сбросить фильтры", exact=True)).to_be_visible()
+            page.goto("http://miem.test/admin")
+            page.wait_for_function("document.querySelector('[data-progress-panel]').getAttribute('aria-busy') === 'true'")
+            pending.pop(0).fulfill(status=503, body="unavailable")
+            expect(page.locator("[data-progress-error]")).to_be_visible()
+            expect(page.get_by_text("Показаны последние полученные данные.", exact=False)).to_be_visible()
+            page.get_by_role("button", name="Повторить").click()
+            page.wait_for_timeout(100)
+            pending.pop(0).fulfill(json={"running": None, "latest": None})
+            expect(page.locator("[data-progress-error]")).to_be_hidden()
+            expect(page.get_by_text("Запусков пока нет. Запустите парсинг.", exact=True)).to_be_visible()
+            assert not errors, errors
+            browser.close()
+    finally:
+        app.dependency_overrides.clear()
+        client.close()
+        engine.dispose()
+    print(f"Browser checks passed; screenshots: {output}")
+
+
+if __name__ == "__main__":
+    main()

tests/test_academic_degrees.py

@@ -0,0 +1,26 @@
+from app.services.academic_degrees import academic_degrees
+
+
+def test_academic_degrees_extracts_all_degree_names_without_surrounding_text():
+    data = {
+        "sections": [
+            {
+                "title": "Образование",
+                "year_entries": [
+                    {"text": "2008 — кандидат технических наук, доцент"},
+                    {"text": "2018 — Доктор физико-математических наук"},
+                ],
+            },
+            {
+                "title": "Учёные степени",
+                "table": {"rows": [{"cells": ["Ph.D.", "Доктор физико-математических наук"]}]},
+            },
+            {"title": "Публикации", "items": ["Доктор медицинских наук выступил автором статьи"]},
+        ]
+    }
+
+    assert academic_degrees(data) == [
+        "кандидат технических наук",
+        "Доктор физико-математических наук",
+        "Ph.D.",
+    ]

tests/test_admin_data.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 
-from app.models import CrawlError, CrawlRun, CrawlRunEmployeeChange, Employee
+from app.models import CrawlError, CrawlRun, CrawlRunEmployeeChange, Employee, EmployeeNewsLink
 from app.services.admin_data import (
     employee_detail_payload,
     employee_display_payload,
@@ -35,6 +35,7 @@ def test_employee_display_payload_extracts_common_fields(db_session):
             "sections": [
                 {"type": "publications", "publications": [{"title": "Paper"}]},
                 {"type": "courses_by_year", "courses": [{"title": "Course"}]},
+                {"type": "news", "news_links": [{"title": "News", "url": "https://example.test/news"}]},
             ],
         },
     )
@@ -46,9 +47,55 @@ def test_employee_display_payload_extracts_common_fields(db_session):
     assert payload["email_text"] == "person@hse.ru"
     assert payload["publications_count"] == 1
     assert payload["courses_count"] == 1
+    assert payload["news_count"] == 1
     assert payload["first_seen_display"] != "Не указано"
 
 
+def test_list_employees_page_filters_and_displays_academic_degrees(db_session):
+    db_session.add_all(
+        [
+            Employee(
+                profile_key="staff:degree",
+                canonical_url="https://www.hse.ru/staff/degree",
+                full_name="Doctor",
+                status="active",
+                first_seen_at=datetime.now(timezone.utc),
+                last_seen_at=datetime.now(timezone.utc),
+                has_academic_degree=True,
+                current_data={
+                    "sections": [
+                        {
+                            "title": "Образование и учёные степени",
+                            "year_entries": [{"year": 2020, "text": "Доктор технических наук"}],
+                        }
+                    ]
+                },
+            ),
+            Employee(
+                profile_key="staff:no-degree",
+                canonical_url="https://www.hse.ru/staff/no-degree",
+                full_name="Master",
+                status="active",
+                first_seen_at=datetime.now(timezone.utc),
+                last_seen_at=datetime.now(timezone.utc),
+                has_academic_degree=False,
+                current_data={"sections": [{"title": "Образование", "items": ["Магистратура"]}]},
+            ),
+        ]
+    )
+    db_session.commit()
+
+    page = list_employees_page(db_session, has_academic_degree=True)
+
+    assert page["total"] == 1
+    assert page["employees"][0]["full_name"] == "Doctor"
+    assert page["employees"][0]["academic_degree_text"] == "Доктор технических наук"
+
+    page = list_employees_page(db_session, has_academic_degree=False)
+
+    assert page["employees"][0]["full_name"] == "Master"
+
+
 def test_employee_detail_payload_normalizes_human_readable_sections(db_session):
     employee = Employee(
         profile_key="staff:person",
@@ -104,6 +151,19 @@ def test_employee_detail_payload_normalizes_human_readable_sections(db_session):
                     "type": "generic",
                     "raw_text": "Fallback text",
                 },
+                {
+                    "title": "В новостях",
+                    "type": "news",
+                    "news_links": [
+                        {
+                            "title": "News title",
+                            "url": "https://example.test/news",
+                            "summary": "News summary",
+                            "published_at": "2026-04-28T00:00:00+00:00",
+                            "published_year": 2026,
+                        }
+                    ],
+                },
             ],
         },
     )
@@ -118,6 +178,41 @@ def test_employee_detail_payload_normalizes_human_readable_sections(db_session):
     assert payload["sections"][2]["courses"][0]["title"] == "Course"
     assert payload["sections"][3]["theses"][0]["student"] == "Student Name"
     assert payload["sections"][4]["paragraphs"] == ["Fallback text"]
+    assert payload["sections"][5]["news_links"][0]["title"] == "News title"
+    assert payload["news_links"][0]["published_display"] == "28.04.2026"
+
+
+def test_employee_payload_prefers_stored_news_links(db_session):
+    employee = Employee(
+        profile_key="staff:news",
+        canonical_url="https://www.hse.ru/staff/news",
+        full_name="News Person",
+        status="active",
+        first_seen_at=datetime.now(timezone.utc),
+        last_seen_at=datetime.now(timezone.utc),
+        current_data={"sections": [{"type": "news", "news_links": [{"title": "Old news"}]}]},
+    )
+    db_session.add(employee)
+    db_session.commit()
+    db_session.add(
+        EmployeeNewsLink(
+            employee_id=employee.id,
+            title="Stored news",
+            url="https://example.test/stored",
+            summary="Stored summary",
+            published_at=datetime(2026, 4, 28, tzinfo=timezone.utc),
+            published_year=2026,
+            source_hash="b" * 64,
+        )
+    )
+    db_session.commit()
+
+    display = employee_display_payload(employee)
+    detail = employee_detail_payload(employee)
+
+    assert display["news_count"] == 1
+    assert detail["news_links"][0]["title"] == "Stored news"
+    assert detail["news_links"][0]["published_display"] == "28.04.2026"
 
 
 def test_employee_payloads_tolerate_malformed_current_data(db_session):
@@ -173,6 +268,18 @@ def test_list_employees_page_filters_sorts_and_paginates(db_session):
     assert page["limit"] == 50
 
 
+def test_catalog_recovers_from_out_of_range_offset(db_session):
+    db_session.add(Employee(profile_key="staff:page", canonical_url="https://www.hse.ru/staff/page", full_name="Page Person"))
+    db_session.commit()
+
+    page = list_employees_page(db_session, q="Page", offset=100, limit=25)
+    assert (page["offset"], page["page"], page["total"]) == (0, 1, 1)
+    assert len(page["employees"]) == 1
+    empty = list_employees_page(db_session, q="missing", offset=100)
+    assert empty["offset"] == 0
+    assert empty["employees"] == []
+
+
 def test_stats_payload_uses_latest_run_new_count(db_session):
     db_session.add(
         Employee(

tests/test_admin_templates.py

@@ -1,93 +1,128 @@
-from pathlib import Path
-
-
-def test_base_navigation_is_russian_and_has_no_legacy_employees_link():
-    template = Path("app/templates/base.html").read_text(encoding="utf-8")
-
-    assert "Обзор" in template
-    assert "Сотрудники" in template
-    assert "Запуски" in template
-    assert "Выйти" in template
-    assert '<a class="admin__brand-link" href="/admin">MIEM Employees</a>' in template
-    assert ">Employees<" not in template
-    assert "/admin/employees" not in template
-
-
-def test_directory_template_is_russian_and_uses_display_dates():
-    template = Path("app/templates/directory.html").read_text(encoding="utf-8")
-
-    assert "Сотрудники" in template
-    assert "Колонки" in template
-    assert "Применить" in template
-    assert "На странице: {{ value }}" in template
-    assert "{% for value in [25, 50, 100] %}" in template
-    assert "Найдено:" in template
-    assert "employee.first_seen_display" in template
-    assert "employee.last_seen_display" in template
-    assert "employee.dismissed_display" in template
-    assert "Directory" not in template
-    assert "employees found" not in template
-
-
-def test_admin_employees_route_redirects_to_directory():
-    source = Path("app/admin.py").read_text(encoding="utf-8")
-
-    assert 'RedirectResponse("/admin/directory", status_code=303)' in source
-
-
-def test_dashboard_limits_latest_runs_to_five():
-    source = Path("app/admin.py").read_text(encoding="utf-8")
-
-    assert "order_by(desc(CrawlRun.started_at)).limit(5)" in source
-    assert "order_by(desc(CrawlRun.started_at)).limit(10)" not in source
-
-
-def test_runs_template_links_to_run_detail():
-    template = Path("app/templates/runs.html").read_text(encoding="utf-8")
-
-    assert 'onclick="window.location.href=\'/admin/runs/{{ run.id }}\'"' in template
-    assert "onkeydown=\"if (event.key === 'Enter' || event.key === ' ')" in template
-    assert 'role="link"' in template
-    assert 'tabindex="0"' in template
-    assert 'data-row-href="/admin/runs/{{ run.id }}"' not in template
-    assert '<a class="admin__link" href="/admin/runs/{{ run.id }}">' not in template
-
-
-def test_run_detail_template_extends_base_and_shows_change_groups():
-    template = Path("app/templates/run_detail.html").read_text(encoding="utf-8")
-
-    assert '{% extends "base.html" %}' in template
-    assert 'id="new-employees"' in template
-    assert "Новые сотрудники" in template
-    assert "Потеряшки" in template
-    assert "Уволенные" in template
-    assert "Детализация сотрудников для этого запуска недоступна" in template
-
-
+from pathlib import Path
+
+
+def test_base_navigation_is_russian_and_has_no_legacy_employees_link():
+    template = Path("app/templates/base.html").read_text(encoding="utf-8")
+
+    assert "Обзор" in template
+    assert "Сотрудники" in template
+    assert "Запуски" in template
+    assert "Выйти" in template
+    assert '<a class="admin__brand-link" href="/admin">MIEM Employees</a>' in template
+    assert ">Employees<" not in template
+    assert "/admin/employees" not in template
+
+
+def test_directory_template_is_russian_and_uses_display_dates():
+    template = Path("app/templates/directory.html").read_text(encoding="utf-8")
+
+    assert "Сотрудники" in template
+    assert "колонки" in template
+    assert "Применить фильтры" in template
+    assert "Сотрудников на странице" in template
+    assert "{% for value in [25, 50, 100] %}" in template
+    assert "Показаны" in template
+    assert "Новости" in template
+    assert "Есть учёная степень" in template
+    assert 'data-column="academic_degree"' in template
+    assert "employee.news_count" in template
+    assert "employee.first_seen_display" in template
+    assert "employee.last_seen_display" in template
+    assert "employee.dismissed_display" in template
+    assert "verification_required" in template
+    assert '<label class="directory__field">Статус' in template
+    assert 'id="columns-dialog"' in template
+    assert 'aria-controls="columns-dialog"' in template
+    assert 'aria-labelledby="columns-dialog-title"' in template
+    assert "Сбросить фильтры" in template
+    assert 'data-columns-preset="review"' in template
+    assert '<dialog class="columns-modal"' in template
+    assert 'id="columns-dialog"' in template
+    assert 'aria-controls="columns-dialog"' in template
+    assert "Сбросить фильтры" in template
+    assert "Directory" not in template
+    assert "employees found" not in template
+
+
+def test_admin_employees_route_redirects_to_directory():
+    source = Path("app/admin.py").read_text(encoding="utf-8")
+
+    assert 'RedirectResponse("/admin/directory", status_code=303)' in source
+
+
+def test_dashboard_limits_latest_runs_to_five():
+    source = Path("app/admin.py").read_text(encoding="utf-8")
+
+    assert "order_by(desc(CrawlRun.started_at)).limit(5)" in source
+    assert "order_by(desc(CrawlRun.started_at)).limit(10)" not in source
+
+
+def test_runs_template_links_to_run_detail():
+    template = Path("app/templates/runs.html").read_text(encoding="utf-8")
+
+    assert '<a class="admin__link" href="/admin/runs/{{ run.id }}">' in template
+    assert "onclick=" not in template
+    assert 'role="link"' not in template
+
+
+def test_run_detail_template_extends_base_and_shows_change_groups():
+    template = Path("app/templates/run_detail.html").read_text(encoding="utf-8")
+
+    assert '{% extends "base.html" %}' in template
+    assert 'id="new-employees"' in template
+    assert "Новые сотрудники" in template
+    assert "Потеряшки" in template
+    assert "Требуют проверки" in template
+    assert "Уволенные" in template
+    assert "Детализация сотрудников для этого запуска недоступна" in template
+
+
 def test_dashboard_metric_cards_link_to_admin_targets():
-    template = Path("app/templates/dashboard.html").read_text(encoding="utf-8")
-
-    assert 'href="/admin/directory"' in template
-    assert 'href="/admin/directory?status=active"' in template
-    assert '/admin/runs/{{ latest_run.id }}#new-employees' in template
-    assert 'href="/admin/directory?status=dismissed"' in template
+    template = Path("app/templates/dashboard.html").read_text(encoding="utf-8")
+
+    assert 'href="/admin/directory"' in template
+    assert 'href="/admin/directory?status=active"' in template
+    assert 'href="/admin/directory?status=verification_required"' in template
+    assert '/admin/runs/{{ latest_run.id }}#new-employees' in template
+    assert 'href="/admin/directory?status=dismissed"' in template
     assert 'href="/admin/runs"' in template
 
 
-def test_dashboard_latest_run_rows_link_to_run_detail():
+def test_dashboard_has_dismissed_status_refresh_action():
     template = Path("app/templates/dashboard.html").read_text(encoding="utf-8")
 
-    assert 'onclick="window.location.href=\'/admin/runs/{{ run.id }}\'"' in template
-    assert "onkeydown=\"if (event.key === 'Enter' || event.key === ' ')" in template
-    assert 'role="link"' in template
-    assert 'tabindex="0"' in template
-    assert 'data-row-href="/admin/runs/{{ run.id }}"' not in template
-    assert '<a class="admin__link" href="/admin/runs/{{ run.id }}">' not in template
+    assert 'action="/admin/dismissed/refresh"' in template
+    assert "Проверить уволенных" in template
 
 
-def test_admin_js_supports_keyboard_activation_for_clickable_rows():
+def test_progress_template_has_accessible_progressbar():
+    for name in ("dashboard.html", "runs.html"):
+        template = Path(f"app/templates/{name}").read_text(encoding="utf-8")
+        assert 'role="progressbar"' in template
+        assert 'aria-valuemin="0"' in template
+        assert 'aria-valuemax="100"' in template
+        assert "Прогресс парсинга" in template
+
+
+def test_dashboard_latest_run_rows_link_to_run_detail():
+    template = Path("app/templates/dashboard.html").read_text(encoding="utf-8")
+
+    assert '<a class="admin__link" href="/admin/runs/{{ run.id }}">' in template
+    assert "onclick=" not in template
+    assert 'role="link"' not in template
+
+
+def test_admin_js_uses_native_dialog_for_column_settings():
     source = Path("app/static/admin.js").read_text(encoding="utf-8")
 
-    assert 'addEventListener("keydown"' in source
-    assert '"Enter"' in source
-    assert '" "' in source
+    assert "showModal()" in source
+    assert "modal.close()" in source
+    assert 'setAttribute("aria-expanded", "true")' in source
+    assert "data-progress-retry" in source
+
+
+def test_base_template_has_skip_link_and_current_navigation_state():
+    template = Path("app/templates/base.html").read_text(encoding="utf-8")
+
+    assert 'href="#main-content"' in template
+    assert 'aria-current="page"' in template

tests/test_api.py

@@ -0,0 +1,158 @@
+from datetime import datetime, timezone
+from types import SimpleNamespace
+
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine, select
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import StaticPool
+
+from app.config import Settings, get_settings
+from app.db import Base, get_db
+from app.main import app
+from app.models import CrawlRun, CrawlRunEmployeeChange, Employee
+from app.security import SESSION_COOKIE, sign_session
+
+
+def test_health_returns_versions():
+    response = TestClient(app).get("/api/health")
+
+    assert response.status_code == 200
+    assert response.json()["backend_version"] == "0.8.1"
+
+
+def test_mcp_endpoint_is_removed():
+    assert TestClient(app).get("/mcp").status_code == 404
+
+
+def test_api_employees_and_stats_require_admin_session():
+    engine = create_engine("sqlite:///:memory:", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    session_factory = sessionmaker(bind=engine)
+    db = session_factory()
+    employee = Employee(
+        profile_key="staff:alpha",
+        profile_type="staff",
+        profile_id="alpha",
+        canonical_url="https://www.hse.ru/staff/alpha",
+        full_name="Alpha Person",
+        status="active",
+        first_seen_at=datetime.now(timezone.utc),
+        last_seen_at=datetime.now(timezone.utc),
+        current_data={"contacts": {"emails": ["alpha@hse.ru"]}, "sections": []},
+    )
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="completed", new_count=1)
+    db.add_all([employee, run])
+    db.commit()
+    db.add(CrawlRunEmployeeChange(
+        crawl_run_id=run.id,
+        employee_id=employee.id,
+        profile_key=employee.profile_key,
+        profile_url=employee.canonical_url,
+        full_name=employee.full_name,
+        change_type="new",
+        profile_available=True,
+        message="added",
+    ))
+    db.commit()
+    run_id = run.id
+    db.close()
+
+    settings = Settings(admin_username="admin", admin_password="password", session_secret="session-secret")
+
+    def override_db():
+        session = session_factory()
+        try:
+            yield session
+        finally:
+            session.close()
+
+    app.dependency_overrides[get_db] = override_db
+    app.dependency_overrides[get_settings] = lambda: settings
+    client = TestClient(app)
+    client.cookies.set(SESSION_COOKIE, sign_session("admin", settings))
+
+    employees = client.get("/api/employees", params={"q": "Alpha", "has_email": True})
+    stats = client.get("/api/stats")
+    run_details = client.get(f"/api/crawl-runs/{run_id}")
+
+    assert employees.status_code == 200
+    assert employees.json()["total"] == 1
+    assert stats.status_code == 200
+    assert stats.json()["new_in_last_run"] == 1
+    assert run_details.status_code == 200
+    assert run_details.json()["changes"]["new"][0]["full_name"] == "Alpha Person"
+    directory = client.get("/admin/directory?q=Alpha&offset=100")
+    assert directory.status_code == 200
+    assert "Показаны 1–1 из 1" in directory.text
+    assert 'name="offset"' not in directory.text
+    assert "Alpha Person" in directory.text
+    empty = client.get("/admin/directory?q=missing&offset=100")
+    assert "Показаны 0–0 из 0" in empty.text
+    assert "Сбросить фильтры" in empty.text
+    app.dependency_overrides.clear()
+
+
+def test_admin_refresh_employee_route_updates_only_requested_employee(monkeypatch):
+    engine = create_engine("sqlite:///:memory:", connect_args={"check_same_thread": False}, poolclass=StaticPool)
+    Base.metadata.create_all(engine)
+    session_factory = sessionmaker(bind=engine)
+    db = session_factory()
+    db.add(Employee(
+        profile_key="org_person:133709486",
+        profile_type="org_person",
+        profile_id="133709486",
+        canonical_url="https://www.hse.ru/org/persons/133709486",
+        full_name="Будков Юрий Алексеевич",
+        status="active",
+    ))
+    db.commit()
+    employee_id = db.scalar(select(Employee.id))
+    db.close()
+
+    settings = Settings(admin_username="admin", admin_password="password", session_secret="session-secret")
+
+    def override_db():
+        session = session_factory()
+        try:
+            yield session
+        finally:
+            session.close()
+
+    calls = []
+
+    def fake_refresh_employee(db, refreshed_employee, route_settings):
+        calls.append((refreshed_employee.id, route_settings))
+        return SimpleNamespace(status="completed")
+
+    app.dependency_overrides[get_db] = override_db
+    app.dependency_overrides[get_settings] = lambda: settings
+    monkeypatch.setattr("app.admin.refresh_employee", fake_refresh_employee)
+    client = TestClient(app)
+    client.cookies.set(SESSION_COOKIE, sign_session("admin", settings))
+
+    response = client.post(f"/admin/employees/{employee_id}/refresh", follow_redirects=False)
+
+    assert response.status_code == 303
+    assert response.headers["location"] == f"/admin/employees/{employee_id}?refresh_status=success"
+    assert calls == [(employee_id, settings)]
+    app.dependency_overrides.clear()
+
+
+def test_directory_database_error_has_retry_and_preserves_filters(db_session, monkeypatch):
+    settings = Settings(_env_file=None, session_secret="test-session-secret")
+    app.dependency_overrides[get_db] = lambda: db_session
+    app.dependency_overrides[get_settings] = lambda: settings
+    def unavailable(*args, **kwargs):
+        raise OperationalError("SELECT", {}, Exception("private database details"))
+    monkeypatch.setattr("app.admin.list_employees_page", unavailable)
+    try:
+        client = TestClient(app)
+        client.cookies.set(SESSION_COOKIE, sign_session(settings.admin_username, settings))
+        response = client.get("/admin/directory?q=Alice")
+        assert response.status_code == 503
+        assert 'href="/admin/directory?q=Alice"' in response.text
+        assert "Повторить загрузку" in response.text
+        assert "private database details" not in response.text
+    finally:
+        app.dependency_overrides.clear()

tests/test_api_mcp.py

@@ -1,532 +0,0 @@
-import json
-from datetime import datetime, timezone
-from types import SimpleNamespace
-
-from fastapi.testclient import TestClient
-from sqlalchemy import create_engine, select
-from sqlalchemy.orm import sessionmaker
-from sqlalchemy.pool import StaticPool
-
-from app.config import Settings, get_settings
-from app.db import Base, get_db
-from app.main import app
-from app.models import CrawlRun, CrawlRunEmployeeChange, Employee, EmployeePublication
-from app.security import SESSION_COOKIE, sign_session
-
-
-def test_health_returns_versions():
-    client = TestClient(app)
-
-    response = client.get("/api/health")
-
-    assert response.status_code == 200
-    assert response.json()["backend_version"] == "0.6.2"
-
-
-def test_mcp_lists_tools_without_auth_and_ignores_auth_header():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-
-    def override_db():
-        session = Session()
-        try:
-            yield session
-        finally:
-            session.close()
-
-    app.dependency_overrides[get_db] = override_db
-    client = TestClient(app)
-
-    without_auth = client.post("/mcp", json={"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}})
-    with_auth = client.post(
-        "/mcp",
-        headers={"Authorization": "Bearer anything"},
-        json={"jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {}},
-    )
-
-    assert without_auth.status_code == 200
-    assert with_auth.status_code == 200
-    tool_names = {tool["name"] for tool in without_auth.json()["result"]["tools"]}
-    assert "search_employees" in tool_names
-    assert "get_service_info" in tool_names
-    assert "sync_employees" in tool_names
-    assert any(tool["name"] == "get_crawl_run_details" for tool in without_auth.json()["result"]["tools"])
-    assert with_auth.json()["result"]["tools"] == without_auth.json()["result"]["tools"]
-
-    app.dependency_overrides.clear()
-
-
-def test_mcp_search_employees_returns_matching_employee():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    session.add(
-        Employee(
-            profile_key="staff:avsergeev",
-            profile_type="staff",
-            profile_id="avsergeev",
-            canonical_url="https://www.hse.ru/staff/avsergeev",
-            full_name="Сергеев Алексей Викторович",
-            status="active",
-            first_seen_at=datetime.now(timezone.utc),
-            last_seen_at=datetime.now(timezone.utc),
-            current_data={"sections": []},
-        )
-    )
-    session.commit()
-    session.close()
-
-    def override_db():
-        db = Session()
-        try:
-            yield db
-        finally:
-            db.close()
-
-    app.dependency_overrides[get_db] = override_db
-    client = TestClient(app)
-
-    response = client.post(
-        "/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": "tools/call",
-            "params": {"name": "search_employees", "arguments": {"query": "Сергеев"}},
-        },
-    )
-
-    assert response.status_code == 200
-    assert "Сергеев Алексей Викторович" in response.json()["result"]["content"][0]["text"]
-
-    app.dependency_overrides.clear()
-
-
-def test_mcp_service_info_returns_tools_and_dataset_hash():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    session.add(
-        Employee(
-            profile_key="staff:alpha",
-            profile_type="staff",
-            profile_id="alpha",
-            canonical_url="https://www.hse.ru/staff/alpha",
-            full_name="Alpha Person",
-            status="active",
-            current_checksum="a" * 64,
-            current_data={"sections": []},
-        )
-    )
-    session.commit()
-    session.close()
-
-    def override_db():
-        db = Session()
-        try:
-            yield db
-        finally:
-            db.close()
-
-    app.dependency_overrides[get_db] = override_db
-    client = TestClient(app)
-
-    response = client.post(
-        "/mcp",
-        json={"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "get_service_info", "arguments": {}}},
-    )
-
-    assert response.status_code == 200
-    payload = json.loads(response.json()["result"]["content"][0]["text"])
-    assert payload["service_name"] == "miem-employees"
-    assert payload["backend_version"] == "0.6.2"
-    assert payload["dataset"]["hash"]
-    assert any(tool["name"] == "sync_employees" for tool in payload["tools"])
-
-    app.dependency_overrides.clear()
-
-
-def test_mcp_list_employee_publications_prefers_stored_publications_with_fallback():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    stored_employee = Employee(
-        profile_key="staff:stored",
-        profile_type="staff",
-        profile_id="stored",
-        canonical_url="https://www.hse.ru/staff/stored",
-        full_name="Stored Person",
-        status="active",
-        current_data={
-            "sections": [
-                {
-                    "type": "publications",
-                    "publications": [{"title": "Old JSON Publication", "url": "https://example.test/old"}],
-                }
-            ]
-        },
-    )
-    fallback_employee = Employee(
-        profile_key="staff:fallback",
-        profile_type="staff",
-        profile_id="fallback",
-        canonical_url="https://www.hse.ru/staff/fallback",
-        full_name="Fallback Person",
-        status="active",
-        current_data={
-            "sections": [
-                {
-                    "type": "publications",
-                    "publications": [{"title": "Fallback Publication", "url": "https://example.test/fallback"}],
-                }
-            ]
-        },
-    )
-    session.add_all([stored_employee, fallback_employee])
-    session.commit()
-    session.add(
-        EmployeePublication(
-            employee_id=stored_employee.id,
-            publication_id="pub-1",
-            title="Stored Publication",
-            year=2024,
-            publication_type="ARTICLE",
-            url="https://publications.hse.ru/view/pub-1",
-            doi_url="https://doi.org/10.1/test",
-            citation_text="Stored Citation",
-            annotation={"ru": "Аннотация", "en": "Abstract"},
-            description={"main": "Stored Citation"},
-            authors=[{"id": "1", "title_ru": "Автор", "is_current_employee": True}],
-            source_hash="a" * 64,
-        )
-    )
-    session.commit()
-    session.close()
-
-    def override_db():
-        db = Session()
-        try:
-            yield db
-        finally:
-            db.close()
-
-    app.dependency_overrides[get_db] = override_db
-    client = TestClient(app)
-
-    stored_response = client.post(
-        "/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": "tools/call",
-            "params": {"name": "list_employee_publications", "arguments": {"profile_id_or_url": "stored"}},
-        },
-    )
-    fallback_response = client.post(
-        "/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 2,
-            "method": "tools/call",
-            "params": {"name": "list_employee_publications", "arguments": {"profile_id_or_url": "fallback"}},
-        },
-    )
-
-    stored_payload = json.loads(stored_response.json()["result"]["content"][0]["text"])
-    fallback_payload = json.loads(fallback_response.json()["result"]["content"][0]["text"])
-    assert stored_payload["items"][0]["title"] == "Stored Publication"
-    assert stored_payload["items"][0]["doi_url"] == "https://doi.org/10.1/test"
-    assert stored_payload["items"][0]["annotation"] == {"ru": "Аннотация", "en": "Abstract"}
-    assert stored_payload["items"][0]["authors"] == [{"id": "1", "title_ru": "Автор", "is_current_employee": True}]
-    assert fallback_payload["items"][0]["title"] == "Fallback Publication"
-
-    app.dependency_overrides.clear()
-
-
-def test_mcp_sync_employees_full_empty_and_unknown_hash_modes():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    session.add(
-        Employee(
-            profile_key="staff:alpha",
-            profile_type="staff",
-            profile_id="alpha",
-            canonical_url="https://www.hse.ru/staff/alpha",
-            full_name="Alpha Person",
-            status="active",
-            current_checksum="a" * 64,
-            current_data={"sections": [{"type": "paragraphs"}]},
-        )
-    )
-    session.commit()
-    session.close()
-
-    def override_db():
-        db = Session()
-        try:
-            yield db
-        finally:
-            db.close()
-
-    app.dependency_overrides[get_db] = override_db
-    client = TestClient(app)
-
-    full_response = client.post(
-        "/mcp",
-        json={"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "sync_employees", "arguments": {}}},
-    )
-    full_payload = json.loads(full_response.json()["result"]["content"][0]["text"])
-    current_hash = full_payload["to_hash"]
-
-    empty_response = client.post(
-        "/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 2,
-            "method": "tools/call",
-            "params": {"name": "sync_employees", "arguments": {"client_hash": current_hash}},
-        },
-    )
-    empty_payload = json.loads(empty_response.json()["result"]["content"][0]["text"])
-
-    unknown_response = client.post(
-        "/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 3,
-            "method": "tools/call",
-            "params": {"name": "sync_employees", "arguments": {"client_hash": "missing"}},
-        },
-    )
-    unknown_payload = json.loads(unknown_response.json()["result"]["content"][0]["text"])
-
-    assert full_payload["mode"] == "full"
-    assert full_payload["items"][0]["data"] == {"sections": [{"type": "paragraphs"}]}
-    assert empty_payload["mode"] == "delta"
-    assert empty_payload["changes"] == {"added": [], "updated": [], "dismissed": [], "removed": []}
-    assert unknown_payload["mode"] == "full"
-    assert unknown_payload["reason"] == "unknown_client_hash"
-
-    app.dependency_overrides.clear()
-
-
-def test_mcp_get_crawl_run_details_returns_changes():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    session = Session()
-    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="completed", new_count=1)
-    employee = Employee(
-        profile_key="staff:new",
-        profile_type="staff",
-        profile_id="new",
-        canonical_url="https://www.hse.ru/staff/new",
-        full_name="New Person",
-        status="active",
-        first_seen_at=datetime.now(timezone.utc),
-        last_seen_at=datetime.now(timezone.utc),
-    )
-    session.add_all([run, employee])
-    session.commit()
-    session.add(
-        CrawlRunEmployeeChange(
-            crawl_run_id=run.id,
-            employee_id=employee.id,
-            profile_key=employee.profile_key,
-            profile_url=employee.canonical_url,
-            full_name=employee.full_name,
-            change_type="new",
-            profile_available=True,
-            message="added",
-        )
-    )
-    session.commit()
-    run_id = run.id
-    session.close()
-
-    def override_db():
-        db = Session()
-        try:
-            yield db
-        finally:
-            db.close()
-
-    app.dependency_overrides[get_db] = override_db
-    client = TestClient(app)
-
-    response = client.post(
-        "/mcp",
-        json={
-            "jsonrpc": "2.0",
-            "id": 1,
-            "method": "tools/call",
-            "params": {"name": "get_crawl_run_details", "arguments": {"run_id": run_id}},
-        },
-    )
-
-    assert response.status_code == 200
-    text = response.json()["result"]["content"][0]["text"]
-    assert "New Person" in text
-    assert "changes_detail_available" in text
-
-    app.dependency_overrides.clear()
-
-
-def test_mcp_protected_resource_metadata_route_is_removed():
-    client = TestClient(app)
-
-    response = client.get("/.well-known/oauth-protected-resource")
-
-    assert response.status_code == 404
-
-
-def test_api_employees_and_stats_require_admin_session():
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    db = Session()
-    db.add(
-        Employee(
-            profile_key="staff:alpha",
-            profile_type="staff",
-            profile_id="alpha",
-            canonical_url="https://www.hse.ru/staff/alpha",
-            full_name="Alpha Person",
-            status="active",
-            first_seen_at=datetime.now(timezone.utc),
-            last_seen_at=datetime.now(timezone.utc),
-            current_data={"contacts": {"emails": ["alpha@hse.ru"]}, "sections": []},
-        )
-    )
-    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="completed", new_count=1)
-    db.add(run)
-    db.commit()
-    db.add(
-        CrawlRunEmployeeChange(
-            crawl_run_id=run.id,
-            employee_id=1,
-            profile_key="staff:alpha",
-            profile_url="https://www.hse.ru/staff/alpha",
-            full_name="Alpha Person",
-            change_type="new",
-            profile_available=True,
-            message="added",
-        )
-    )
-    db.commit()
-    run_id = run.id
-    db.close()
-
-    settings = Settings(admin_username="admin", admin_password="password", session_secret="session-secret")
-
-    def override_db():
-        session = Session()
-        try:
-            yield session
-        finally:
-            session.close()
-
-    app.dependency_overrides[get_db] = override_db
-    app.dependency_overrides[get_settings] = lambda: settings
-    client = TestClient(app)
-    client.cookies.set(SESSION_COOKIE, sign_session("admin", settings))
-
-    employees = client.get("/api/employees", params={"q": "Alpha", "has_email": True})
-    stats = client.get("/api/stats")
-    run_details = client.get(f"/api/crawl-runs/{run_id}")
-
-    assert employees.status_code == 200
-    assert employees.json()["total"] == 1
-    assert stats.status_code == 200
-    assert stats.json()["new_in_last_run"] == 1
-    assert run_details.status_code == 200
-    assert run_details.json()["changes"]["new"][0]["full_name"] == "Alpha Person"
-
-    app.dependency_overrides.clear()
-
-
-def test_admin_refresh_employee_route_updates_only_requested_employee(monkeypatch):
-    engine = create_engine(
-        "sqlite:///:memory:",
-        connect_args={"check_same_thread": False},
-        poolclass=StaticPool,
-    )
-    Base.metadata.create_all(engine)
-    Session = sessionmaker(bind=engine)
-    db = Session()
-    db.add(
-        Employee(
-            profile_key="org_person:133709486",
-            profile_type="org_person",
-            profile_id="133709486",
-            canonical_url="https://www.hse.ru/org/persons/133709486",
-            full_name="Будков Юрий Алексеевич",
-            status="active",
-        )
-    )
-    db.commit()
-    employee_id = db.scalar(select(Employee.id))
-    db.close()
-
-    settings = Settings(admin_username="admin", admin_password="password", session_secret="session-secret")
-
-    def override_db():
-        session = Session()
-        try:
-            yield session
-        finally:
-            session.close()
-
-    calls = []
-
-    def fake_refresh_employee(db, refreshed_employee, route_settings):
-        calls.append((refreshed_employee.id, route_settings))
-        return SimpleNamespace(status="completed")
-
-    app.dependency_overrides[get_db] = override_db
-    app.dependency_overrides[get_settings] = lambda: settings
-    monkeypatch.setattr("app.admin.refresh_employee", fake_refresh_employee)
-    client = TestClient(app)
-    client.cookies.set(SESSION_COOKIE, sign_session("admin", settings))
-
-    response = client.post(f"/admin/employees/{employee_id}/refresh", follow_redirects=False)
-
-    assert response.status_code == 303
-    assert response.headers["location"] == f"/admin/employees/{employee_id}?refresh_status=success"
-    assert calls == [(employee_id, settings)]
-
-    app.dependency_overrides.clear()

tests/test_crawler.py

@@ -1,316 +1,575 @@
-import gzip
-from datetime import datetime, timezone
-
-from app.models import CrawlError, CrawlRun, CrawlRunEmployeeChange, Employee, EmployeePublication, EmployeeSnapshot, ParseResourceCache
-from app.services.crawler import _checksum, _mark_dismissed, _upsert_employee
-from app.services.resource_cache import ResourceCache
-
-
-class FakeResponse:
-    def __init__(self, status_code):
-        self.status_code = status_code
-
-
-class FakeSession:
-    def __init__(self, statuses):
-        self.statuses = statuses
-
-    def get(self, url, **_kwargs):
-        return FakeResponse(self.statuses[url])
-
-
-class ConditionalResponse:
-    def __init__(self, status_code, text="", headers=None):
-        self.status_code = status_code
-        self._text = text
-        self.headers = headers or {}
-        self.text_read = False
-
-    @property
-    def text(self):
-        self.text_read = True
-        return self._text
-
-    def raise_for_status(self):
-        return None
-
-
+import gzip
+from datetime import datetime, timezone
+
+from app.models import (
+    CrawlError,
+    CrawlRun,
+    CrawlRunEmployeeChange,
+    Employee,
+    EmployeeNewsLink,
+    EmployeePublication,
+    EmployeeSnapshot,
+    ParseResourceCache,
+)
+from app.config import Settings
+from app.services.crawler import _checksum, _mark_dismissed, _upsert_employee, refresh_dismissed_status
+from app.services.resource_cache import ResourceCache
+
+
+class FakeResponse:
+    def __init__(self, status_code):
+        self.status_code = status_code
+
+
+class FakeSession:
+    def __init__(self, statuses):
+        self.statuses = statuses
+
+    def get(self, url, **_kwargs):
+        return FakeResponse(self.statuses[url])
+
+
+class ConditionalResponse:
+    def __init__(self, status_code, text="", headers=None):
+        self.status_code = status_code
+        self._text = text
+        self.headers = headers or {}
+        self.text_read = False
+
+    @property
+    def text(self):
+        self.text_read = True
+        return self._text
+
+    def raise_for_status(self):
+        return None
+
+
 class ConditionalSession:
-    def __init__(self):
-        self.requests = []
-        self.not_modified_response = ConditionalResponse(304)
-
-    def get(self, url, **kwargs):
-        self.requests.append((url, kwargs))
-        if kwargs["headers"].get("If-None-Match") == '"cached"':
-            return self.not_modified_response
+    def __init__(self):
+        self.requests = []
+        self.not_modified_response = ConditionalResponse(304)
+
+    def get(self, url, **kwargs):
+        self.requests.append((url, kwargs))
+        if kwargs["headers"].get("If-None-Match") == '"cached"':
+            return self.not_modified_response
         return ConditionalResponse(200, "fresh", {"ETag": '"fresh"'})
 
 
-def test_mark_dismissed_records_missing_source_when_profile_is_available(db_session):
-    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    db_session.add(run)
-    db_session.add(
-        Employee(
-            profile_key="staff:kept",
-            canonical_url="https://www.hse.ru/staff/kept",
-            status="active",
-            first_seen_at=datetime.now(timezone.utc),
-            last_seen_at=datetime.now(timezone.utc),
-        )
+def test_refresh_dismissed_status_reactivates_only_profiles_in_source(monkeypatch, db_session):
+    now = datetime.now(timezone.utc)
+    found = Employee(
+        profile_key="staff:returned",
+        canonical_url="https://www.hse.ru/staff/returned",
+        status="dismissed",
+        dismissed_at=now,
+        first_seen_at=now,
+        last_seen_at=now,
     )
-    db_session.add(
-        Employee(
-            profile_key="staff:missing",
-            canonical_url="https://www.hse.ru/staff/missing",
-            status="active",
-            first_seen_at=datetime.now(timezone.utc),
-            last_seen_at=datetime.now(timezone.utc),
-        )
-    )
-    db_session.commit()
-
-    dismissed = _mark_dismissed(
-        db_session,
-        run,
-        {"staff:kept"},
-        FakeSession({"https://www.hse.ru/staff/missing": 200}),
-        30,
-    )
-
-    assert dismissed == 0
-    assert db_session.query(Employee).filter_by(profile_key="staff:kept").one().status == "active"
-    missing = db_session.query(Employee).filter_by(profile_key="staff:missing").one()
-    assert missing.status == "active"
-    assert missing.dismissed_at is None
-    change = db_session.query(CrawlRunEmployeeChange).one()
-    assert change.change_type == "missing_from_source"
-    assert change.profile_available is True
-
-
-def test_mark_dismissed_marks_missing_employee_when_profile_is_unavailable(db_session):
-    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    employee = Employee(
+    still_dismissed = Employee(
         profile_key="staff:gone",
         canonical_url="https://www.hse.ru/staff/gone",
-        status="active",
-        first_seen_at=datetime.now(timezone.utc),
-        last_seen_at=datetime.now(timezone.utc),
+        status="dismissed",
+        dismissed_at=now,
+        first_seen_at=now,
+        last_seen_at=now,
     )
-    db_session.add_all([run, employee])
+    db_session.add_all([found, still_dismissed])
     db_session.commit()
-
-    dismissed = _mark_dismissed(
-        db_session,
-        run,
-        set(),
-        FakeSession({"https://www.hse.ru/staff/gone": 404}),
-        30,
+    monkeypatch.setattr(
+        "app.services.crawler.collect_profile_links",
+        lambda *_args, **_kwargs: ["https://www.hse.ru/staff/returned"],
     )
 
-    assert dismissed == 1
-    assert employee.status == "dismissed"
-    assert employee.dismissed_at is not None
-    change = db_session.query(CrawlRunEmployeeChange).one()
-    assert change.change_type == "dismissed"
-    assert change.profile_available is False
-
-
-def test_upsert_employee_increments_new_count_and_records_change_for_new_employee(db_session):
-    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    db_session.add(run)
-    db_session.commit()
-
-    _upsert_employee(
-        db_session,
-        run,
-        {
-            "source_url": "https://www.hse.ru/staff/newperson",
-            "profile_type": "staff",
-            "profile_id": "newperson",
-            "full_name": "New Person",
-            "tabs": [],
-            "sections": [],
-            "parser_version": "0.2.0",
-            "_html": "<html></html>",
-        },
-    )
-    db_session.commit()
+    run = refresh_dismissed_status(db_session, Settings())
 
+    assert run.status == "completed"
+    assert run.parsed_count == 1
+    assert run.skipped_count == 1
+    assert found.status == "active"
+    assert found.dismissed_at is None
+    assert still_dismissed.status == "dismissed"
+
+
+def test_mark_dismissed_records_missing_source_when_profile_is_available(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add(run)
+    db_session.add(
+        Employee(
+            profile_key="staff:kept",
+            canonical_url="https://www.hse.ru/staff/kept",
+            status="active",
+            first_seen_at=datetime.now(timezone.utc),
+            last_seen_at=datetime.now(timezone.utc),
+        )
+    )
+    db_session.add(
+        Employee(
+            profile_key="staff:missing",
+            canonical_url="https://www.hse.ru/staff/missing",
+            status="active",
+            first_seen_at=datetime.now(timezone.utc),
+            last_seen_at=datetime.now(timezone.utc),
+        )
+    )
+    db_session.commit()
+
+    dismissed = _mark_dismissed(
+        db_session,
+        run,
+        {"staff:kept"},
+        FakeSession({"https://www.hse.ru/staff/missing": 200}),
+        30,
+    )
+
+    assert dismissed == 0
+    assert db_session.query(Employee).filter_by(profile_key="staff:kept").one().status == "active"
+    missing = db_session.query(Employee).filter_by(profile_key="staff:missing").one()
+    assert missing.status == "active"
+    assert missing.dismissed_at is None
+    change = db_session.query(CrawlRunEmployeeChange).one()
+    assert change.change_type == "missing_from_source"
+    assert change.profile_available is True
+
+
+def test_mark_dismissed_requires_consecutive_unavailable_checks(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    employee = Employee(
+        profile_key="staff:gone",
+        canonical_url="https://www.hse.ru/staff/gone",
+        status="active",
+        first_seen_at=datetime.now(timezone.utc),
+        last_seen_at=datetime.now(timezone.utc),
+    )
+    db_session.add_all([run, employee])
+    db_session.commit()
+
+    first_check = _mark_dismissed(
+        db_session,
+        run,
+        set(),
+        FakeSession({"https://www.hse.ru/staff/gone": 404}),
+        30,
+        confirmation_runs=2,
+    )
+
+    assert first_check == 0
+    assert employee.status == "verification_required"
+    assert employee.dismissed_at is None
+    assert employee.profile_unavailable_streak == 1
+    assert db_session.query(CrawlRunEmployeeChange).one().change_type == "verification_required"
+
+    second_check = _mark_dismissed(
+        db_session,
+        run,
+        set(),
+        FakeSession({"https://www.hse.ru/staff/gone": 404}),
+        30,
+        confirmation_runs=2,
+    )
+
+    assert second_check == 1
+    assert employee.status == "dismissed"
+    assert employee.dismissed_at is not None
+    assert employee.profile_unavailable_streak == 2
+    change = db_session.query(CrawlRunEmployeeChange).order_by(CrawlRunEmployeeChange.id).all()[-1]
+    assert change.change_type == "dismissed"
+    assert change.profile_available is False
+
+
+def test_mark_dismissed_does_not_dismiss_on_server_error(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    employee = Employee(
+        profile_key="staff:temporary-error",
+        canonical_url="https://www.hse.ru/staff/temporary-error",
+        status="active",
+        first_seen_at=datetime.now(timezone.utc),
+        last_seen_at=datetime.now(timezone.utc),
+    )
+    db_session.add_all([run, employee])
+    db_session.commit()
+
+    dismissed = _mark_dismissed(
+        db_session,
+        run,
+        set(),
+        FakeSession({"https://www.hse.ru/staff/temporary-error": 503}),
+        30,
+        confirmation_runs=1,
+    )
+
+    assert dismissed == 0
+    assert employee.status == "active"
+    assert employee.profile_unavailable_streak == 0
+    assert db_session.query(CrawlError).one().error_type == "ProfileAvailabilityCheckError"
+
+
+def test_available_profile_resets_verification_streak(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    employee = Employee(
+        profile_key="staff:restored",
+        canonical_url="https://www.hse.ru/staff/restored",
+        status="active",
+        first_seen_at=datetime.now(timezone.utc),
+        last_seen_at=datetime.now(timezone.utc),
+    )
+    db_session.add_all([run, employee])
+    db_session.commit()
+
+    _mark_dismissed(
+        db_session,
+        run,
+        set(),
+        FakeSession({"https://www.hse.ru/staff/restored": 404}),
+        30,
+        confirmation_runs=3,
+    )
+    _mark_dismissed(
+        db_session,
+        run,
+        set(),
+        FakeSession({"https://www.hse.ru/staff/restored": 200}),
+        30,
+        confirmation_runs=3,
+    )
+
+    assert employee.status == "active"
+    assert employee.profile_unavailable_streak == 0
+
+
+def test_mark_dismissed_blocks_mass_auto_dismissals(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    employees = [
+        Employee(
+            profile_key=f"staff:gone-{index}",
+            canonical_url=f"https://www.hse.ru/staff/gone-{index}",
+            status="active",
+            first_seen_at=datetime.now(timezone.utc),
+            last_seen_at=datetime.now(timezone.utc),
+        )
+        for index in range(2)
+    ]
+    db_session.add_all([run, *employees])
+    db_session.commit()
+
+    dismissed = _mark_dismissed(
+        db_session,
+        run,
+        set(),
+        FakeSession({employee.canonical_url: 404 for employee in employees}),
+        30,
+        confirmation_runs=1,
+        max_auto_dismissals=1,
+    )
+
+    assert dismissed == 0
+    assert {employee.status for employee in employees} == {"verification_required"}
+    assert "приостановлено" in run.message
+
+
+def test_upsert_employee_increments_new_count_and_records_change_for_new_employee(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add(run)
+    db_session.commit()
+
+    employee, _ = _upsert_employee(
+        db_session,
+        run,
+        {
+            "source_url": "https://www.hse.ru/staff/newperson",
+            "profile_type": "staff",
+            "profile_id": "newperson",
+            "full_name": "New Person",
+            "tabs": [],
+            "sections": [
+                {
+                    "title": "Образование и учёные степени",
+                    "year_entries": [{"text": "Кандидат технических наук"}],
+                }
+            ],
+            "parser_version": "0.2.0",
+            "_html": "<html></html>",
+        },
+    )
+    db_session.commit()
+
     assert run.new_count == 1
-    change = db_session.query(CrawlRunEmployeeChange).one()
-    assert change.change_type == "new"
-    assert change.full_name == "New Person"
-
-
-def test_resource_cache_uses_etag_and_reuses_cached_body_on_304(db_session):
-    db_session.add(
-        ParseResourceCache(
-            profile_key="staff:cached",
-            resource_key="main-html",
-            method="GET",
-            url="https://www.hse.ru/staff/cached",
-            request_fingerprint="020d59db7b358d9023d0f185bcbf5a9c085d3cf2bf91d92d48eee9147e8d0f01",
-            etag='"cached"',
-            body_hash="cached-hash",
-            body_snapshot=gzip.compress("cached body".encode("utf-8")),
-            parser_version="0.6.0",
-        )
-    )
-    db_session.commit()
-    session = ConditionalSession()
-
-    result = ResourceCache(db_session).fetch_text(
-        session,
-        profile_key="staff:cached",
-        resource_key="main-html",
-        method="GET",
-        url="https://www.hse.ru/staff/cached",
-        headers={"User-Agent": "test"},
-        timeout=10,
-    )
-
-    assert session.requests[0][1]["headers"]["If-None-Match"] == '"cached"'
-    assert result.text == "cached body"
-    assert result.from_cache is True
-    assert session.not_modified_response.text_read is False
-
-
-def test_upsert_employee_skips_snapshot_when_checksum_is_unchanged(db_session):
-    first_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    second_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    db_session.add_all([first_run, second_run])
-    db_session.commit()
-
-    _, first_changed = _upsert_employee(db_session, first_run, _parsed_employee("same"))
-    _, second_changed = _upsert_employee(db_session, second_run, _parsed_employee("same"))
-    db_session.commit()
-
-    assert first_changed is True
-    assert second_changed is False
-    assert db_session.query(EmployeeSnapshot).count() == 1
-
-
-def test_upsert_employee_saves_publications_and_reuses_existing_rows(db_session):
-    first_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    second_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    db_session.add_all([first_run, second_run])
-    db_session.commit()
-
-    parsed = _parsed_employee("published")
-    parsed["sections"] = [
-        {
-            "type": "publications",
-            "publications": [
-                {
-                    "id": "888959076",
-                    "publication_id": "888959076",
-                    "title": "Detailed Publication",
-                    "year": 2023,
-                    "publication_type": "ARTICLE",
-                    "language": "ru",
-                    "status": 1,
-                    "url": "https://publications.hse.ru/view/888959076",
-                    "doi_url": "https://doi.org/10.1/test",
-                    "citation_text": "Detailed citation",
-                    "annotation": {"ru": "Аннотация"},
-                    "description": {"main": "Detailed citation"},
-                    "authors": [{"id": "1", "title_ru": "Автор"}],
-                    "raw_data": {"id": "888959076", "title": "Detailed Publication"},
-                }
-            ],
-        }
-    ]
-
-    employee, _ = _upsert_employee(db_session, first_run, parsed)
-    db_session.commit()
-    _upsert_employee(db_session, second_run, _parsed_employee_with_publication("published"))
-    db_session.commit()
-
-    publications = db_session.query(EmployeePublication).filter_by(employee_id=employee.id).all()
-    assert len(publications) == 1
-    assert publications[0].doi_url == "https://doi.org/10.1/test"
-    assert publications[0].authors == [{"id": "1", "title_ru": "Автор"}]
-
-
-def test_upsert_employee_records_publication_errors_without_failing_employee(monkeypatch, db_session):
-    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
-    db_session.add(run)
-    db_session.commit()
-
-    def broken_sync(*_args, **_kwargs):
-        raise RuntimeError("boom")
-
-    monkeypatch.setattr("app.services.crawler._sync_employee_publications", broken_sync)
-
-    employee, changed = _upsert_employee(db_session, run, _parsed_employee_with_publication("error-safe"))
-    db_session.commit()
-
-    assert changed is True
-    assert employee.full_name == "Same Person"
-    assert db_session.query(Employee).filter_by(profile_key="staff:error-safe").one()
-    error = db_session.query(CrawlError).one()
-    assert "публикации" in error.message.lower()
-
-
-def test_checksum_changes_when_widget_data_changes():
-    base = _parsed_employee("widgets")
-    changed = _parsed_employee("widgets")
-    changed["sections"] = [
-        {
-            "type": "publications",
-            "publications": [{"id": "1", "title": "New publication"}],
-        }
-    ]
-
-    assert _checksum(base) != _checksum(changed)
-
-
-def test_checksum_ignores_date_dependent_experience_text():
-    first = _parsed_employee("experience")
-    second = _parsed_employee("experience")
-    first["sections"] = [{"raw_text": "Стаж работы в НИУ ВШЭ: 5 лет"}]
-    second["sections"] = [{"raw_text": "Стаж работы в НИУ ВШЭ: 6 лет"}]
-
-    assert _checksum(first) == _checksum(second)
-
-
-def _parsed_employee(profile_id: str) -> dict:
-    return {
-        "source_url": f"https://www.hse.ru/staff/{profile_id}",
-        "profile_type": "staff",
-        "profile_id": profile_id,
-        "full_name": "Same Person",
-        "tabs": [],
-        "sections": [],
-        "parser_version": "0.6.0",
-        "_html": "<html></html>",
-    }
-
-
-def _parsed_employee_with_publication(profile_id: str) -> dict:
-    parsed = _parsed_employee(profile_id)
-    parsed["sections"] = [
-        {
-            "type": "publications",
-            "publications": [
-                {
-                    "id": "888959076",
-                    "publication_id": "888959076",
-                    "title": "Detailed Publication",
-                    "year": 2023,
-                    "publication_type": "ARTICLE",
-                    "language": "ru",
-                    "status": 1,
-                    "url": "https://publications.hse.ru/view/888959076",
-                    "doi_url": "https://doi.org/10.1/test",
-                    "citation_text": "Detailed citation",
-                    "annotation": {"ru": "Аннотация"},
-                    "description": {"main": "Detailed citation"},
-                    "authors": [{"id": "1", "title_ru": "Автор"}],
-                    "raw_data": {"id": "888959076", "title": "Detailed Publication"},
-                }
-            ],
-        }
-    ]
-    return parsed
+    assert employee.has_academic_degree is True
+    change = db_session.query(CrawlRunEmployeeChange).one()
+    assert change.change_type == "new"
+    assert change.full_name == "New Person"
+
+
+def test_upsert_employee_reconciles_profile_moved_to_new_url(db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    employee = Employee(
+        profile_key="staff:abelov",
+        canonical_url="https://www.hse.ru/staff/abelov",
+        full_name="Белов Александр Владимирович",
+        status="active",
+        first_seen_at=datetime.now(timezone.utc),
+        last_seen_at=datetime.now(timezone.utc),
+    )
+    db_session.add_all([run, employee])
+    db_session.commit()
+    employee_id = employee.id
+
+    updated, changed = _upsert_employee(
+        db_session,
+        run,
+        {
+            "source_url": "https://www.hse.ru/org/persons/47634735",
+            "profile_type": "org_person",
+            "profile_id": "47634735",
+            "full_name": "Белов Александр Владимирович",
+            "tabs": [],
+            "sections": [],
+            "parser_version": "0.7.0",
+            "_html": "<html></html>",
+        },
+    )
+    db_session.commit()
+
+    assert changed is True
+    assert updated.id == employee_id
+    assert updated.profile_key == "org_person:47634735"
+    assert updated.canonical_url == "https://www.hse.ru/org/persons/47634735"
+    assert updated.status == "active"
+    assert run.new_count == 0
+    assert db_session.query(Employee).count() == 1
+    assert {item.url for item in updated.profile_urls} == {
+        "https://www.hse.ru/staff/abelov",
+        "https://www.hse.ru/org/persons/47634735",
+    }
+
+
+def test_resource_cache_uses_etag_and_reuses_cached_body_on_304(db_session):
+    db_session.add(
+        ParseResourceCache(
+            profile_key="staff:cached",
+            resource_key="main-html",
+            method="GET",
+            url="https://www.hse.ru/staff/cached",
+            request_fingerprint="020d59db7b358d9023d0f185bcbf5a9c085d3cf2bf91d92d48eee9147e8d0f01",
+            etag='"cached"',
+            body_hash="cached-hash",
+            body_snapshot=gzip.compress("cached body".encode("utf-8")),
+            parser_version="0.6.0",
+        )
+    )
+    db_session.commit()
+    session = ConditionalSession()
+
+    result = ResourceCache(db_session).fetch_text(
+        session,
+        profile_key="staff:cached",
+        resource_key="main-html",
+        method="GET",
+        url="https://www.hse.ru/staff/cached",
+        headers={"User-Agent": "test"},
+        timeout=10,
+    )
+
+    assert session.requests[0][1]["headers"]["If-None-Match"] == '"cached"'
+    assert result.text == "cached body"
+    assert result.from_cache is True
+    assert session.not_modified_response.text_read is False
+
+
+def test_upsert_employee_skips_snapshot_when_checksum_is_unchanged(db_session):
+    first_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    second_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add_all([first_run, second_run])
+    db_session.commit()
+
+    _, first_changed = _upsert_employee(db_session, first_run, _parsed_employee("same"))
+    _, second_changed = _upsert_employee(db_session, second_run, _parsed_employee("same"))
+    db_session.commit()
+
+    assert first_changed is True
+    assert second_changed is False
+    assert db_session.query(EmployeeSnapshot).count() == 1
+
+
+def test_upsert_employee_saves_publications_and_reuses_existing_rows(db_session):
+    first_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    second_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add_all([first_run, second_run])
+    db_session.commit()
+
+    parsed = _parsed_employee("published")
+    parsed["sections"] = [
+        {
+            "type": "publications",
+            "publications": [
+                {
+                    "id": "888959076",
+                    "publication_id": "888959076",
+                    "title": "Detailed Publication",
+                    "year": 2023,
+                    "publication_type": "ARTICLE",
+                    "language": "ru",
+                    "status": 1,
+                    "url": "https://publications.hse.ru/view/888959076",
+                    "doi_url": "https://doi.org/10.1/test",
+                    "citation_text": "Detailed citation",
+                    "annotation": {"ru": "Аннотация"},
+                    "description": {"main": "Detailed citation"},
+                    "authors": [{"id": "1", "title_ru": "Автор"}],
+                    "raw_data": {"id": "888959076", "title": "Detailed Publication"},
+                }
+            ],
+        }
+    ]
+
+    employee, _ = _upsert_employee(db_session, first_run, parsed)
+    db_session.commit()
+    _upsert_employee(db_session, second_run, _parsed_employee_with_publication("published"))
+    db_session.commit()
+
+    publications = db_session.query(EmployeePublication).filter_by(employee_id=employee.id).all()
+    assert len(publications) == 1
+    assert publications[0].doi_url == "https://doi.org/10.1/test"
+    assert publications[0].authors == [{"id": "1", "title_ru": "Автор"}]
+
+
+def test_upsert_employee_records_publication_errors_without_failing_employee(monkeypatch, db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add(run)
+    db_session.commit()
+
+    def broken_sync(*_args, **_kwargs):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr("app.services.crawler._sync_employee_publications", broken_sync)
+
+    employee, changed = _upsert_employee(db_session, run, _parsed_employee_with_publication("error-safe"))
+    db_session.commit()
+
+    assert changed is True
+    assert employee.full_name == "Same Person"
+    assert db_session.query(Employee).filter_by(profile_key="staff:error-safe").one()
+    error = db_session.query(CrawlError).one()
+    assert "публикации" in error.message.lower()
+
+
+def test_upsert_employee_saves_news_links_and_reuses_existing_rows(db_session):
+    first_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    second_run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add_all([first_run, second_run])
+    db_session.commit()
+
+    employee, _ = _upsert_employee(db_session, first_run, _parsed_employee_with_news("news-person"))
+    db_session.commit()
+    _upsert_employee(db_session, second_run, _parsed_employee_with_news("news-person"))
+    db_session.commit()
+
+    news_links = db_session.query(EmployeeNewsLink).filter_by(employee_id=employee.id).all()
+    assert len(news_links) == 1
+    assert news_links[0].title == "News Title"
+    assert news_links[0].url == "https://www.hse.ru/news/1.html"
+    assert news_links[0].published_year == 2026
+
+
+def test_upsert_employee_records_news_errors_without_failing_employee(monkeypatch, db_session):
+    run = CrawlRun(source_url="https://miem.hse.ru/persons", status="running")
+    db_session.add(run)
+    db_session.commit()
+
+    def broken_sync(*_args, **_kwargs):
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr("app.services.crawler._sync_employee_news_links", broken_sync)
+
+    employee, changed = _upsert_employee(db_session, run, _parsed_employee_with_news("news-error-safe"))
+    db_session.commit()
+
+    assert changed is True
+    assert employee.full_name == "Same Person"
+    assert db_session.query(Employee).filter_by(profile_key="staff:news-error-safe").one()
+    error = db_session.query(CrawlError).one()
+    assert "новости" in error.message.lower()
+
+
+def test_checksum_changes_when_widget_data_changes():
+    base = _parsed_employee("widgets")
+    changed = _parsed_employee("widgets")
+    changed["sections"] = [
+        {
+            "type": "publications",
+            "publications": [{"id": "1", "title": "New publication"}],
+        }
+    ]
+
+    assert _checksum(base) != _checksum(changed)
+
+
+def test_checksum_ignores_date_dependent_experience_text():
+    first = _parsed_employee("experience")
+    second = _parsed_employee("experience")
+    first["sections"] = [{"raw_text": "Стаж работы в НИУ ВШЭ: 5 лет"}]
+    second["sections"] = [{"raw_text": "Стаж работы в НИУ ВШЭ: 6 лет"}]
+
+    assert _checksum(first) == _checksum(second)
+
+
+def _parsed_employee(profile_id: str) -> dict:
+    return {
+        "source_url": f"https://www.hse.ru/staff/{profile_id}",
+        "profile_type": "staff",
+        "profile_id": profile_id,
+        "full_name": "Same Person",
+        "tabs": [],
+        "sections": [],
+        "parser_version": "0.6.0",
+        "_html": "<html></html>",
+    }
+
+
+def _parsed_employee_with_publication(profile_id: str) -> dict:
+    parsed = _parsed_employee(profile_id)
+    parsed["sections"] = [
+        {
+            "type": "publications",
+            "publications": [
+                {
+                    "id": "888959076",
+                    "publication_id": "888959076",
+                    "title": "Detailed Publication",
+                    "year": 2023,
+                    "publication_type": "ARTICLE",
+                    "language": "ru",
+                    "status": 1,
+                    "url": "https://publications.hse.ru/view/888959076",
+                    "doi_url": "https://doi.org/10.1/test",
+                    "citation_text": "Detailed citation",
+                    "annotation": {"ru": "Аннотация"},
+                    "description": {"main": "Detailed citation"},
+                    "authors": [{"id": "1", "title_ru": "Автор"}],
+                    "raw_data": {"id": "888959076", "title": "Detailed Publication"},
+                }
+            ],
+        }
+    ]
+    return parsed
+
+
+def _parsed_employee_with_news(profile_id: str) -> dict:
+    parsed = _parsed_employee(profile_id)
+    parsed["sections"] = [
+        {
+            "type": "news",
+            "news_links": [
+                {
+                    "title": "News Title",
+                    "url": "https://www.hse.ru/news/1.html",
+                    "summary": "News summary",
+                    "published_at": "2026-04-28T00:00:00+00:00",
+                    "published_year": 2026,
+                    "raw_data": {"title": "News Title", "url": "https://www.hse.ru/news/1.html"},
+                }
+            ],
+        }
+    ]
+    return parsed

tests/test_dataset_versions.py

@@ -1,88 +0,0 @@
-from datetime import datetime, timezone
-
-from app.models import Employee
-from app.services.dataset_versions import get_or_create_current_version, sync_employees_payload
-
-
-def _employee(profile_key: str, checksum: str, *, status: str = "active") -> Employee:
-    return Employee(
-        profile_key=profile_key,
-        profile_type=profile_key.split(":", 1)[0],
-        profile_id=profile_key.split(":", 1)[1],
-        canonical_url=f"https://www.hse.ru/{profile_key}",
-        full_name=profile_key,
-        status=status,
-        first_seen_at=datetime.now(timezone.utc),
-        last_seen_at=datetime.now(timezone.utc),
-        current_data={"profile_key": profile_key},
-        current_checksum=checksum,
-    )
-
-
-def test_dataset_version_hash_is_stable_for_same_employee_state(db_session):
-    db_session.add(_employee("staff:alpha", "a" * 64))
-    db_session.commit()
-
-    first = get_or_create_current_version(db_session)
-    db_session.commit()
-    second = get_or_create_current_version(db_session)
-
-    assert second.id == first.id
-    assert second.hash == first.hash
-    assert second.employee_count == 1
-
-
-def test_dataset_version_hash_changes_when_employee_checksum_changes(db_session):
-    employee = _employee("staff:alpha", "a" * 64)
-    db_session.add(employee)
-    db_session.commit()
-    first = get_or_create_current_version(db_session)
-    db_session.commit()
-
-    employee.current_checksum = "b" * 64
-    db_session.commit()
-    second = get_or_create_current_version(db_session)
-
-    assert second.hash != first.hash
-    assert second.previous_hash == first.hash
-
-
-def test_sync_employees_diff_spans_multiple_intermediate_versions(db_session):
-    alpha = _employee("staff:alpha", "a" * 64)
-    db_session.add(alpha)
-    db_session.commit()
-    first = get_or_create_current_version(db_session)
-    db_session.commit()
-
-    beta = _employee("staff:beta", "b" * 64)
-    db_session.add(beta)
-    db_session.commit()
-    get_or_create_current_version(db_session)
-    db_session.commit()
-
-    alpha.current_checksum = "c" * 64
-    alpha.current_data = {"profile_key": "staff:alpha", "changed": True}
-    db_session.commit()
-
-    payload = sync_employees_payload(db_session, client_hash=first.hash, include_data=False)
-
-    assert payload["mode"] == "delta"
-    assert [item["profile_key"] for item in payload["changes"]["added"]] == ["staff:beta"]
-    assert [item["profile_key"] for item in payload["changes"]["updated"]] == ["staff:alpha"]
-    assert payload["changes"]["dismissed"] == []
-    assert payload["changes"]["removed"] == []
-
-
-def test_sync_employees_reports_dismissed_as_tombstone(db_session):
-    alpha = _employee("staff:alpha", "a" * 64)
-    db_session.add(alpha)
-    db_session.commit()
-    first = get_or_create_current_version(db_session)
-    db_session.commit()
-
-    alpha.status = "dismissed"
-    db_session.commit()
-    payload = sync_employees_payload(db_session, client_hash=first.hash, include_data=False)
-
-    assert payload["changes"]["dismissed"][0]["profile_key"] == "staff:alpha"
-    assert payload["changes"]["dismissed"][0]["status"] == "dismissed"

tests/test_db_schema.py

@@ -69,3 +69,76 @@ def test_runtime_schema_creates_employee_publications_table_when_employees_exist
     assert "employee_publications" in inspector.get_table_names()
     columns = {column["name"] for column in inspector.get_columns("employee_publications")}
     assert {"employee_id", "publication_id", "doi_url", "authors", "raw_data", "source_hash"}.issubset(columns)
+
+
+def test_runtime_schema_creates_employee_news_links_table_when_employees_exist(monkeypatch):
+    engine = create_engine("sqlite:///:memory:")
+    with engine.begin() as connection:
+        connection.execute(
+            text(
+                """
+                CREATE TABLE employees (
+                  id INTEGER PRIMARY KEY,
+                  profile_key VARCHAR(255) NOT NULL UNIQUE,
+                  canonical_url TEXT NOT NULL,
+                  status VARCHAR(32) NOT NULL DEFAULT 'active',
+                  first_seen_at DATETIME NOT NULL,
+                  last_seen_at DATETIME NOT NULL,
+                  created_at DATETIME NOT NULL,
+                  updated_at DATETIME NOT NULL
+                )
+                """
+            )
+        )
+        connection.execute(
+            text(
+                """
+                CREATE TABLE crawl_runs (
+                  id INTEGER PRIMARY KEY,
+                  source_url TEXT NOT NULL,
+                  status VARCHAR(32) NOT NULL DEFAULT 'running',
+                  found_count INTEGER NOT NULL DEFAULT 0,
+                  parsed_count INTEGER NOT NULL DEFAULT 0,
+                  skipped_count INTEGER NOT NULL DEFAULT 0
+                )
+                """
+            )
+        )
+    monkeypatch.setattr("app.db.engine", engine)
+
+    _ensure_runtime_schema()
+    _ensure_runtime_schema()
+
+    inspector = inspect(engine)
+    assert "employee_news_links" in inspector.get_table_names()
+    columns = {column["name"] for column in inspector.get_columns("employee_news_links")}
+    assert {"employee_id", "title", "url", "summary", "published_at", "published_year", "source_hash", "raw_data"}.issubset(columns)
+
+
+def test_runtime_schema_adds_profile_verification_fields(monkeypatch):
+    engine = create_engine("sqlite:///:memory:")
+    with engine.begin() as connection:
+        connection.execute(
+            text(
+                """
+                CREATE TABLE employees (
+                  id INTEGER PRIMARY KEY,
+                  profile_key VARCHAR(255) NOT NULL UNIQUE,
+                  canonical_url TEXT NOT NULL,
+                  status VARCHAR(32) NOT NULL DEFAULT 'active',
+                  first_seen_at DATETIME NOT NULL,
+                  last_seen_at DATETIME NOT NULL,
+                  created_at DATETIME NOT NULL,
+                  updated_at DATETIME NOT NULL
+                )
+                """
+            )
+        )
+    monkeypatch.setattr("app.db.engine", engine)
+
+    _ensure_runtime_schema()
+
+    inspector = inspect(engine)
+    columns = {column["name"] for column in inspector.get_columns("employees")}
+    assert {"profile_unavailable_streak", "last_profile_check_at", "has_academic_degree"}.issubset(columns)
+    assert "employee_profile_urls" in inspector.get_table_names()

tests/test_employee_detail_template.py

@@ -13,6 +13,9 @@ def test_employee_detail_template_is_human_readable():
     assert "section.list_items" in template
     assert "Основная информация" in template
     assert "Контакты" in template
+    assert "В новостях" in template
+    assert "employee_view.news_links" in template
+    assert "news.summary" in template
     assert "Разделы профиля" in template
     assert "graduation_theses" in template
     assert "Год защиты" in template

tests/test_parser.py

@@ -232,3 +232,45 @@ def test_news_heading_with_publications_word_does_not_absorb_widget_publications
     assert len(publications) == 1
     assert publications[0]["title"] == "Публикации и исследования"
     assert publications[0]["publications_count"] == 1
+
+
+def test_extract_sections_parses_employee_news_links():
+    soup = BeautifulSoup(
+        """
+        <div class="b-person-data posts hidden printable" data-tab="press_links_news" tab-node="press_links_news">
+          <div class="post f8">
+            <div class="post__extra">
+              <div class="post-meta">
+                <div class="post-meta__date">
+                  <div class="post-meta__day">28</div>
+                  <div class="post-meta__month">апр.</div>
+                  <div class="post-meta__year">2026</div>
+                </div>
+              </div>
+            </div>
+            <div class="post__content">
+              <h2 class="first_child"><a class="link" href="/news/edu/1153850518.html">Как финал ВсОШ формирует кадры</a></h2>
+              <div class="post__text"><p class="with-indent">Краткое описание новости.</p></div>
+            </div>
+          </div>
+          <div class="post f8">
+            <div class="post__content">
+              <h2><a href="https://miem.hse.ru/news/1123589375.html">Партнер магистратуры</a></h2>
+            </div>
+          </div>
+        </div>
+        """,
+        "html.parser",
+    )
+
+    sections = extract_sections(soup, "https://www.hse.ru/staff/avsergeev")
+
+    assert len(sections) == 1
+    news = sections[0]
+    assert news["type"] == "news"
+    assert news["news_count"] == 2
+    assert news["news_links"][0]["title"] == "Как финал ВсОШ формирует кадры"
+    assert news["news_links"][0]["url"] == "https://www.hse.ru/news/edu/1153850518.html"
+    assert news["news_links"][0]["summary"] == "Краткое описание новости."
+    assert news["news_links"][0]["published_at"] == "2026-04-28T00:00:00+00:00"
+    assert news["news_links"][0]["published_year"] == 2026