docs: record OpenSearch handoff status

2026-08-14 23:05:10 +03:00
29 changed files with 67 additions and 1465 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,25 +0,0 @@
-# История изменений
-
-## Не выпущено
-
- Добавлен план внутреннего интерфейса оценки поисковой выдачи юристами.
- Завершён Search API v1: стабильные справочники, валидный OpenAPI, безопасная
-  пагинация и проверка актуальных редакций в локальном OpenSearch.
- Добавлено безопасное переключение alias на новую версию поискового индекса
-  после полной загрузки; checkpoint защищает возобновление загрузки от смены
-  alias.
- Добавлен roadmap готовности данных, поиска и API перед проектированием
-  frontend.
- Исправлена выдача для явных запросов об открытии ОсОО и ЖЧК: первыми
-  показываются действующие положение о регистрации и закон о хозяйственных
-  товариществах и обществах.
- Добавлен CLI `python3 -m search.query` для проверки текущей выдачи локального
-  OpenSearch.
- Добавлена инструкция по подготовке и независимой проверке relevance set.
- Улучшено ранжирование relevance-оценки: запрос теперь сопоставляет название и
-  текст документа как единое поле.
-
-## 0.5.0 — 2026-08-15
-
- Добавлена воспроизводимая оценка качества поиска по Recall@10 и MRR@10.
- Подготовлен шаблон relevance set из 25 русских и 25 кыргызских запросов с инструкцией по ручной разметке.
--- a/README.md
+++ b/README.md
@@ -10,15 +10,15 @@ Telegram-бот — только часть рабочего окружения
 ## Текущее состояние

 Сейчас реализованы Telegram-бот-секретарь версии `0.2.2` и backend версии
-`0.7.1`: исправления контракта Search API v1 и его ограничений OpenSearch.
-размеченном наборе запросов.
+`0.4.1`: возобновляемая загрузка индекса документов Министерства юстиции
+ЦБД Минюста КР.

 | Компонент | Версия | Состояние |
 |---|---:|---|
 | Telegram-бот | `0.2.2` | на Synology работает `0.2.1`; обновление после слияния |
-| Backend | `0.7.1` | исправлен контракт Search API v1 |
+| Backend | `0.4.1` | добавлено продолжение прерванной Bulk-загрузки |
 | Frontend | — | ещё не создан |
-| Сбор и обработка правовых данных | `0.7.1` | добавлены relevance set и baseline-метрики |
+| Сбор и обработка правовых данных | `0.4.1` | добавлено продолжение загрузки существующего индекса |
 | RAG и база знаний | — | ещё не созданы |

 ## Структура репозитория
@@ -59,4 +59,4 @@ python3 -m unittest discover -s tools/telegram-bot -v

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/backend/README.md
+++ b/backend/README.md
@@ -1,6 +1,6 @@
 # Backend Акылдаш

-Версия: `0.7.1`
+Версия: `0.4.1`

 Первая backend-область проекта — загрузка правовых документов из официального
 Open Data API ЦБД Минюста Кыргызской Республики. Код расположен в
@@ -128,16 +128,6 @@ python3 backend/search/minjust_opensearch.py \
 После проверки production-индекса следует переключать alias, чтобы удалённые
 фрагменты не оставались в поиске.

-Чтобы переключить alias атомарно только после успешной полной загрузки,
-передайте `--alias`:
-
-```bash
-python3 backend/search/minjust_opensearch.py \
-  --url http://127.0.0.1:9200 \
-  --index akyldash-fragments-v2 \
-  --alias akyldash-fragments-current
-```
-
 После каждого принятого Bulk-пакета загрузчик атомарно сохраняет checkpoint и
 печатает код безопасного возобновления. При временных HTTP 429/5xx, timeout и
 обрыве соединения запрос повторяется автоматически. Прерванную загрузку можно
@@ -152,29 +142,12 @@ python3 backend/search/minjust_opensearch.py \

 По умолчанию checkpoint хранится в
 `data/opensearch/<index>.checkpoint.json`; путь можно изменить через
-`--checkpoint`. Checkpoint привязан к URL, cluster UUID, index UUID, `--limit`,
-`--alias` и SHA-256 нормализованного manifest. При `--resume` передавайте то же
-значение `--alias`; старый checkpoint без alias можно продолжить только без
-него. Resume отклоняется при любом несовпадении:
+`--checkpoint`. Checkpoint привязан к URL, cluster UUID, index UUID, `--limit`
+и SHA-256 нормализованного manifest. Resume отклоняется при любом несовпадении:
 для обновлённого корпуса или пересозданного индекса нужно создать новый
 версионный индекс, проверить его и переключить alias. Это не оставляет
 удалённые trailing-фрагменты старых документов.

-## HTTP API v1
-
-Запустите публичный read-only API поверх текущего alias и нормализованного
-корпуса:
-
-```bash
-PYTHONPATH=backend python3 -m search.api
-```
-
-Он публикует OpenAPI в `GET /openapi.json` и поддерживает `GET /search`,
-`/search/filters`, `/documents/{code}`, `/documents/{code}/editions` и
-`/documents/{code}/editions/{edition}`. Значения фильтров возвращаются со
-стабильным кодом справочника v1 и подписями RU/KY; применяйте `code` как
-параметр поиска. API не подменяет отсутствующий язык документа.
-
 ## Локальный OpenSearch

 Стенд использует один узел OpenSearch без Dashboards, устанавливает
@@ -192,37 +165,6 @@ Security plugin отключён только для локальной разр
 также задаёт одну shard и ноль replicas; для production число shard следует
 рассчитать по размеру корпуса и настроить не менее одной replica.

-## Оценка качества поиска
-
-`search/relevance-set-v1.template.json` содержит заготовку для 25 русских и
-25 кыргызских запросов. Для каждого запроса человек должен указать реальную
-формулировку и коды всех релевантных документов; пустая или неполная разметка
-должна быть отклонена при ручной проверке, а технически некорректная — самим
-оценщиком. Критерии выбора запросов, релевантности и двойной проверки описаны в
-`search/RELEVANCE_ANNOTATION.md`. Рабочую копию следует хранить в игнорируемом
-каталоге `data/`, пока набор не проверен и не разрешён к публикации.
-
-Baseline использует поля названия и текста соответствующего языка, оставляет в
-выдаче один результат на документ и вычисляет макро-средние Recall@10 и MRR@10:
-
-```bash
-mkdir -p data/search
-cp backend/search/relevance-set-v1.template.json data/search/relevance-set-v1.json
-PYTHONPATH=backend python3 -m search.evaluate_relevance \
-  data/search/relevance-set-v1.json \
-  > data/search/baseline-v1.json
-```
-
-Менять веса или анализаторы следует только после фиксации этого baseline и
-разбора ошибок выдачи.
-
-Для проверки текущей выдачи без будущего HTTP API используйте CLI:
-
-```bash
-PYTHONPATH=backend python3 -m search.query "как открыть ОсОО" --language ru
-PYTHONPATH=backend python3 -m search.query "ЖЧК ачуу тартиби" --language ky
-```
-
 ---

-Акылдаш · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Backend v0.4.1 · Frontend — не создан
--- a/backend/ingestion/minjust_cbd.py
+++ b/backend/ingestion/minjust_cbd.py
@@ -21,7 +21,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Callable, Iterable

-APP_VERSION = "0.7.1"
+APP_VERSION = "0.4.1"
 API_BASE_URL = "https://cbd.minjust.gov.kg/api/v1/OpenData/"
 LANGUAGES = {"Rus": "ru", "Kyr": "ky"}
 IMAGE_LANGUAGES = {"Russian": "ru", "Kyrgyz": "ky"}
--- a/backend/normalization/minjust_cbd.py
+++ b/backend/normalization/minjust_cbd.py
@@ -23,7 +23,7 @@ from pathlib import Path
 from typing import Callable
 from urllib.parse import urlsplit

-APP_VERSION = "0.7.1"
+APP_VERSION = "0.4.1"
 SCHEMA_VERSION = "1"
 NORMALIZER_VERSION = "1.0.0"
 LANGUAGES = ("ru", "ky")
--- a/backend/search/RELEVANCE_ANNOTATION.md
+++ b/backend/search/RELEVANCE_ANNOTATION.md
@@ -1,106 +0,0 @@
-# Инструкция по разметке relevance set v1
-
-## Цель
-
-Набор проверяет, находит ли поиск нужные документы по реальным формулировкам
-пользователей. Он не должен подгоняться под текущую выдачу: сначала фиксируются
-запросы и релевантные документы, затем считается baseline и меняется
-ранжирование.
-
-## Подготовка
-
-Создайте игнорируемую Git рабочую копию:
-
-```bash
-mkdir -p data/search
-cp backend/search/relevance-set-v1.template.json data/search/relevance-set-v1.json
-```
-
-Сохраните идентификаторы `ru-01`–`ru-25` и `ky-01`–`ky-25`. Заполняйте
-`query` и `relevant_document_codes`; остальные поля и структуру JSON не меняйте.
-
-## Выбор запросов
-
- Используйте 25 русских и 25 кыргызских запросов, реально заданных или
-  сформулированных носителем языка для практической юридической задачи.
- Не переводите русский набор дословно на кыргызский: оба набора должны
-  отражать естественные формулировки своего языка.
- Записывайте исходную формулировку без улучшения под поисковик. Допустимы
-  разговорные слова, распространённые сокращения и опечатки.
- Не используйте персональные данные, закрытые материалы и сведения, которых
-  нет в публичном корпусе Минюста.
- Не включайте запрос, если нельзя установить хотя бы один релевантный документ.
- Не повторяйте один информационный запрос в нескольких близких формулировках.
-
-Проверьте разнообразие набора: названия и номера актов, вопросы по жизненной
-или рабочей ситуации, короткие тематические запросы, органы принятия, статусы и
-даты. Это ориентир, а не квота: реальные запросы важнее искусственного баланса.
-
-## Критерий релевантности
-
-Документ релевантен, если его текст или реквизиты непосредственно отвечают
-информационной потребности запроса. Добавляйте все такие документы, а не только
-первый результат.
-
-Не отмечайте документ релевантным только потому, что он:
-
- содержит отдельные слова запроса;
- упоминает нужный акт без ответа на запрос;
- относится к близкой теме;
- является утратившей силу редакцией, когда запрос явно требует действующую
-  норму, либо наоборот.
-
-Если запрос допускает несколько самостоятельных правильных документов,
-добавьте коды каждого из них. Код берите из поля `document_code`, а не из ID
-фрагмента или редакции.
-
-## Разметка одного запроса
-
-1. До просмотра выдачи зафиксируйте информационную потребность и формулировку
-   `query`.
-2. Найдите кандидатов в локальном OpenSearch и в официальной ЦБД Минюста.
-   Проверьте исходный запрос, его короткий вариант и вариант с юридическим
-   термином или известным номером акта.
-3. Просмотрите не только заголовки, но и текст, статус, дату и редакцию каждого
-   кандидата.
-4. Запишите уникальные `document_code` всех документов, удовлетворяющих
-   критерию релевантности.
-5. Повторите поиск по ключевым терминам найденных документов, чтобы обнаружить
-   пропущенные альтернативные акты.
-
-Пример структуры (код условный):
-
-```json
-{
-  "id": "ru-01",
-  "language": "ru",
-  "query": "как зарегистрировать общественное объединение",
-  "relevant_document_codes": ["12345"]
-}
-```
-
-## Проверка качества
-
-Второй человек должен проверить формулировку, язык и полный список релевантных
-документов для каждого запроса. Спорные случаи обсуждаются до единого решения;
-результат голосования или непроверенную разметку в baseline не включайте.
-
-Перед запуском убедитесь, что:
-
- заполнены ровно 50 записей: 25 `ru` и 25 `ky`;
- все запросы непустые и различаются по информационной потребности;
- у каждой записи есть хотя бы один уникальный `document_code`;
- язык запроса совпадает с `language`;
- JSON не содержит комментариев и дополнительных полей.
-
-Оценщик дополнительно проверит структуру файла. После ручной проверки
-зафиксируйте копию набора и не меняйте её при настройке поиска:
-
-```bash
-PYTHONPATH=backend python3 -m search.evaluate_relevance \
-  data/search/relevance-set-v1.json \
-  > data/search/baseline-v1.json
-```
-
-Разбирайте запросы с низкими Recall@10 и MRR@10 по отдельности. Меняйте веса,
-анализаторы или словари только после сохранения исходного baseline.
--- a/backend/search/api.py
+++ b/backend/search/api.py
@@ -1,285 +0,0 @@
-"""Minimal HTTP API for the normalized legal-document corpus."""
-
-from __future__ import annotations
-
-import argparse
-import datetime
-import json
-import re
-import urllib.parse
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-
-from search.minjust_opensearch import APP_VERSION, request_json
-from search.catalog import CATALOGS, labels
-
-
-API_VERSION = "v1"
-LANGUAGES = {"ru", "ky"}
-CODE = re.compile(r"^[0-9]+$")
-MAX_PAGE_SIZE = 100
-MAX_RESULT_WINDOW = 10_000
-
-
-class ApiError(Exception):
-    def __init__(self, status: int, message: str):
-        self.status = status
-        self.message = message
-
-
-def parse_positive(value: str | None, name: str, default: int, maximum: int) -> int:
-    if value is None:
-        return default
-    try:
-        parsed = int(value)
-    except ValueError as error:
-        raise ApiError(400, f"{name} must be an integer") from error
-    if not 1 <= parsed <= maximum:
-        raise ApiError(400, f"{name} must be between 1 and {maximum}")
-    return parsed
-
-
-def one(query: dict[str, list[str]], name: str) -> str | None:
-    values = query.get(name, [])
-    if len(values) > 1:
-        raise ApiError(400, f"{name} must be specified once")
-    return values[0] if values else None
-
-
-def date(value: str | None, name: str) -> str | None:
-    if value is None:
-        return None
-    try:
-        datetime.date.fromisoformat(value)
-    except ValueError as error:
-        raise ApiError(400, f"{name} must be an ISO date") from error
-    return value
-
-
-def openapi() -> dict:
-    responses = {"200": {"description": "Successful response"}, "400": {"description": "Invalid request"}, "404": {"description": "Not found"}, "502": {"description": "Search backend unavailable"}}
-    return {
-        "openapi": "3.0.3",
-        "info": {"title": "Akyldash Search API", "version": API_VERSION},
-        "paths": {
-            "/search": {"get": {"responses": responses, "parameters": [
-                {"name": "q", "in": "query", "required": True, "schema": {"type": "string"}},
-                {"name": "language", "in": "query", "schema": {"type": "string", "enum": ["ru", "ky"]}},
-                {"name": "page", "in": "query", "schema": {"type": "integer", "minimum": 1}},
-                {"name": "page_size", "in": "query", "schema": {"type": "integer", "minimum": 1, "maximum": MAX_PAGE_SIZE}},
-                {"name": "document_type", "in": "query", "schema": {"type": "string"}},
-                {"name": "status", "in": "query", "schema": {"type": "string"}},
-                {"name": "authority", "in": "query", "schema": {"type": "string"}},
-                {"name": "date_from", "in": "query", "schema": {"type": "string", "format": "date"}},
-                {"name": "date_to", "in": "query", "schema": {"type": "string", "format": "date"}},
-                {"name": "sort", "in": "query", "schema": {"type": "string", "enum": ["relevance", "date"]}},
-            ]}},
-            "/search/filters": {"get": {"responses": responses}},
-            "/documents/{code}": {"get": {"responses": responses, "parameters": [{"name": "code", "in": "path", "required": True, "schema": {"type": "string", "pattern": "^[0-9]+$"}}]}},
-            "/documents/{code}/editions": {"get": {"responses": responses, "parameters": [{"name": "code", "in": "path", "required": True, "schema": {"type": "string", "pattern": "^[0-9]+$"}}]}},
-            "/documents/{code}/editions/{edition}": {"get": {"responses": responses, "parameters": [{"name": "code", "in": "path", "required": True, "schema": {"type": "string", "pattern": "^[0-9]+$"}}, {"name": "edition", "in": "path", "required": True, "schema": {"type": "string", "pattern": "^[0-9]+$"}}]}},
-        },
-    }
-
-
-class Api:
-    def __init__(self, base_url: str, index: str, data_root: Path):
-        self.base_url = base_url.rstrip("/")
-        self.index = index
-        self.data_root = data_root
-
-    def search_url(self, suffix: str) -> str:
-        return f"{self.base_url}/{urllib.parse.quote(self.index, safe='')}/{suffix}"
-
-    def query_opensearch(self, body: dict) -> dict:
-        try:
-            return request_json(self.search_url("_search"), "POST", json.dumps(body, ensure_ascii=False).encode(), "application/json")
-        except RuntimeError as error:
-            raise ApiError(502, "search backend is unavailable") from error
-
-    def search(self, query: dict[str, list[str]]) -> dict:
-        text = one(query, "q")
-        if not text or not text.strip():
-            raise ApiError(400, "q is required")
-        if len(text) > 500:
-            raise ApiError(400, "q must not exceed 500 characters")
-        language = one(query, "language") or "ru"
-        if language not in LANGUAGES:
-            raise ApiError(400, "language must be ru or ky")
-        page = parse_positive(one(query, "page"), "page", 1, 1_000_000)
-        page_size = parse_positive(one(query, "page_size"), "page_size", 20, MAX_PAGE_SIZE)
-        if page * page_size >= MAX_RESULT_WINDOW:
-            raise ApiError(400, f"page and page_size must stay within {MAX_RESULT_WINDOW} results")
-        sort = one(query, "sort") or "relevance"
-        if sort not in {"relevance", "date"}:
-            raise ApiError(400, "sort must be relevance or date")
-        filters: list[dict] = [{"term": {"language": language}}, {"term": {"is_current_edition": True}}]
-        fields = {"document_type": "document_type_code", "status": "status_code", "authority": "authority_codes"}
-        for parameter, field in fields.items():
-            value = one(query, parameter)
-            if value:
-                if value not in CATALOGS[parameter]:
-                    raise ApiError(400, f"{parameter} must be a catalog code")
-                filters.append({"term": {field: value}})
-        date_from, date_to = date(one(query, "date_from"), "date_from"), date(one(query, "date_to"), "date_to")
-        if date_from and date_to and date_from > date_to:
-            raise ApiError(400, "date_from must not be later than date_to")
-        if date_from or date_to:
-            date_range = {key: value for key, value in (("gte", date_from), ("lte", date_to)) if value}
-            filters.append({"range": {"date_adopted": date_range}})
-        body = {
-            "from": (page - 1) * page_size,
-            "size": page_size + 1,
-            "_source": ["document_code", "edition_code", "document_name_ru", "document_name_ky", "document_type_ru", "document_type_ky", "status_ru", "status_ky", "date_adopted", "number"],
-            "query": {"bool": {"filter": filters, "must": {"multi_match": {"query": text, "fields": [f"document_name_{language}", f"text_{language}"], "type": "cross_fields"}}}},
-            "collapse": {"field": "document_code"},
-            "highlight": {"fields": {f"text_{language}": {"number_of_fragments": 1}}},
-        }
-        if sort == "date":
-            body["sort"] = [{"date_adopted": "desc"}, {"_score": "desc"}]
-        response = self.query_opensearch(body)
-        try:
-            hits = response["hits"]["hits"]
-        except (KeyError, TypeError) as error:
-            raise ApiError(502, "search backend returned an incomplete response") from error
-        return {"api_version": API_VERSION, "query": text, "language": language, "page": page, "page_size": page_size, "has_next": len(hits) > page_size, "results": [self.search_hit(hit, language) for hit in hits[:page_size]]}
-
-    @staticmethod
-    def search_hit(hit: dict, language: str) -> dict:
-        source = hit.get("_source")
-        if not isinstance(source, dict) or not source.get("document_code"):
-            raise ApiError(502, "search backend returned an incomplete result")
-        highlight = hit.get("highlight", {}).get(f"text_{language}", [])
-        return {"code": source["document_code"], "edition": source.get("edition_code"), "name": source.get(f"document_name_{language}"), "type": source.get(f"document_type_{language}"), "status": source.get(f"status_{language}"), "date_adopted": source.get("date_adopted"), "number": source.get("number"), "snippet": highlight[0] if highlight else None}
-
-    def filters(self, query: dict[str, list[str]]) -> dict:
-        language = one(query, "language") or "ru"
-        if language not in LANGUAGES:
-            raise ApiError(400, "language must be ru or ky")
-        fields = {"document_types": ("document_type", "document_type_code"), "statuses": ("status", "status_code"), "authorities": ("authority", "authority_codes")}
-        body = {"size": 0, "query": {"term": {"is_current_edition": True}}, "aggs": {name: {"terms": {"field": pair[1], "size": 1000}, "aggs": {"documents": {"cardinality": {"field": "document_code", "precision_threshold": 40000}}}} for name, pair in fields.items()}}
-        response = self.query_opensearch(body)
-        try:
-            aggregations = response["aggregations"]
-            values = {
-                name: [{"code": item["key"], "labels": labels(pair[0], item["key"]), "count": item["documents"]["value"]} for item in aggregations[name]["buckets"]]
-                for name, pair in fields.items()
-            }
-        except (KeyError, TypeError) as error:
-            raise ApiError(502, "search backend returned incomplete filters") from error
-        return {"api_version": API_VERSION, "language": language, **values}
-
-    def directory(self, code: str) -> Path:
-        if not CODE.fullmatch(code):
-            raise ApiError(404, "document not found")
-        path = self.data_root / "documents" / code
-        if not path.is_dir():
-            raise ApiError(404, "document not found")
-        return path
-
-    @staticmethod
-    def read_json(path: Path, message: str) -> dict:
-        try:
-            value = json.loads(path.read_text(encoding="utf-8"))
-        except (OSError, UnicodeError, json.JSONDecodeError) as error:
-            raise ApiError(500, message) from error
-        if not isinstance(value, dict):
-            raise ApiError(500, message)
-        return value
-
-    def document(self, code: str) -> dict:
-        document = self.read_json(self.directory(code) / "document.json", "document data is unavailable")
-        editions = document.get("editions")
-        if not isinstance(editions, list):
-            raise ApiError(500, "document data is unavailable")
-        return {"api_version": API_VERSION, "document": document, "current_edition": editions[-1] if editions else None}
-
-    def editions(self, code: str) -> dict:
-        document = self.read_json(self.directory(code) / "document.json", "document data is unavailable")
-        return {"api_version": API_VERSION, "code": code, "available_languages": document.get("available_languages", []), "editions": document.get("editions", [])}
-
-    def edition(self, code: str, edition: str, query: dict[str, list[str]]) -> dict:
-        if not CODE.fullmatch(edition):
-            raise ApiError(404, "edition not found")
-        directory = self.directory(code) / "editions" / edition
-        if not directory.is_dir():
-            raise ApiError(404, "edition not found")
-        metadata = self.read_json(directory / "edition.json", "edition data is unavailable")
-        language = one(query, "language")
-        if language is not None and language not in LANGUAGES:
-            raise ApiError(400, "language must be ru or ky")
-        languages = [language] if language else metadata.get("available_languages", [])
-        content = {}
-        for item in languages:
-            if item not in metadata.get("available_languages", []):
-                continue
-            try:
-                content[item] = {"html": (directory / item / "content.html").read_text(encoding="utf-8"), "text": (directory / item / "content.txt").read_text(encoding="utf-8")}
-            except (OSError, UnicodeError) as error:
-                raise ApiError(500, "edition content is unavailable") from error
-        if language and language not in content:
-            raise ApiError(404, "edition language not found")
-        return {"api_version": API_VERSION, "edition": metadata, "content": content}
-
-    def handle(self, method: str, path: str) -> tuple[int, dict]:
-        if method != "GET":
-            raise ApiError(405, "method not allowed")
-        parsed = urllib.parse.urlsplit(path)
-        query = urllib.parse.parse_qs(parsed.query, keep_blank_values=True)
-        parts = [urllib.parse.unquote(part) for part in parsed.path.split("/") if part]
-        if parts == ["openapi.json"]:
-            return 200, openapi()
-        if parts == ["search"]:
-            return 200, self.search(query)
-        if parts == ["search", "filters"]:
-            return 200, self.filters(query)
-        if len(parts) == 2 and parts[0] == "documents":
-            return 200, self.document(parts[1])
-        if len(parts) == 3 and parts[:1] == ["documents"] and parts[2] == "editions":
-            return 200, self.editions(parts[1])
-        if len(parts) == 4 and parts[:1] == ["documents"] and parts[2] == "editions":
-            return 200, self.edition(parts[1], parts[3], query)
-        raise ApiError(404, "endpoint not found")
-
-
-def handler(api: Api):
-    class RequestHandler(BaseHTTPRequestHandler):
-        def respond(self, method: str):
-            try:
-                status, payload = api.handle(method, self.path)
-            except ApiError as error:
-                status, payload = error.status, {"api_version": API_VERSION, "error": error.message}
-            body = json.dumps(payload, ensure_ascii=False).encode()
-            self.send_response(status)
-            self.send_header("Content-Type", "application/json; charset=utf-8")
-            self.send_header("Content-Length", str(len(body)))
-            self.end_headers()
-            self.wfile.write(body)
-
-        def do_GET(self):
-            self.respond("GET")
-
-        def do_POST(self):
-            self.respond("POST")
-
-        def log_message(self, format: str, *args):
-            return
-
-    return RequestHandler
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--url", default="http://127.0.0.1:9200")
-    parser.add_argument("--index", default="akyldash-fragments-current")
-    parser.add_argument("--data", type=Path, default=Path("data/minjust-normalized"))
-    parser.add_argument("--host", default="127.0.0.1")
-    parser.add_argument("--port", type=int, default=8080)
-    parser.add_argument("--version", action="version", version=APP_VERSION)
-    arguments = parser.parse_args()
-    ThreadingHTTPServer((arguments.host, arguments.port), handler(Api(arguments.url, arguments.index, arguments.data))).serve_forever()
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
--- a/backend/search/catalog.py
+++ b/backend/search/catalog.py
@@ -1,51 +0,0 @@
-"""Immutable v1 search catalogs."""
-
-DOCUMENT_TYPES = {
-    "constitution": ("Конституция", "Конституция"), "constitutional_law": ("Конституционный Закон", "Конституциалык Мыйзам"), "code": ("Кодекс", "Кодекс"), "law": ("Закон", "Мыйзам"), "decree": ("Указ", "Жарлык"), "resolution": ("Постановление", "Токтом"), "order": ("Распоряжение", "Распоряжение"), "instruction": ("Инструкция", "Инструкция"), "rules": ("Правила", "Правила"), "procedure": ("Порядок", "Порядок"), "provision": ("Положение", "Жобо"), "regulation": ("Регламент", "Регламент"), "charter": ("Устав", "Жобо (Устав)"), "program": ("Программа", "Программа"), "plan": ("План", "План"), "strategy": ("Стратегия", "Стратегия"), "concept": ("Концепция", "Концепция"), "doctrine": ("Доктрина", "Доктрина"), "agreement": ("Соглашение", "Соглашение"), "declaration": ("Декларация", "Декларация"), "registry": ("Реестр", "Реестр"), "norms": ("Нормативы", "Нормативы"), "model": ("Модель", "Модель"), "matrix": ("Матрица", "Матрица"), "study": ("Исследование", "Исследование"), "report": ("Доклад", "Доклад"), "principles": ("Основные принципы", "Основные принципы"), "unspecified": ("Не указан", "Көрсөтүлгөн эмес"),
-}
-STATUSES = {"active": ("Действует", "Күчүндө"), "repealed": ("Утратил силу", "Күчүн жоготту"), "unspecified": ("Не указан", "Көрсөтүлгөн эмес")}
-AUTHORITIES = {"president": ("Президент", "Президент"), "parliament": ("Органы законодательной власти", "Мыйзам чыгаруу бийлик органдары"), "cabinet": ("Правительство и Кабинет Министров", "Өкмөт жана Министрлер Кабинети"), "ministries_and_committees": ("Министерства и государственные комитеты", "Министрликтер жана мамлекеттик комитеттер"), "administrative_agencies": ("Административные ведомства", "Административдик ведомстволор"), "national_bank": ("Национальный банк", "Улуттук банк"), "other_state_bodies": ("Иные государственные органы", "Башка мамлекеттик органдар"), "local_representative_bodies": ("Представительные органы местного самоуправления", "Жергиликтүү өз алдынча башкаруунун өкүлчүлүктүү органдары"), "other": ("Прочие органы", "Башка органдар")}
-CATALOGS = {"document_type": DOCUMENT_TYPES, "status": STATUSES, "authority": AUTHORITIES}
-
-
-def labels(category: str, code: str) -> dict[str, str]:
-    try:
-        ru, ky = CATALOGS[category][code]
-    except KeyError as error:
-        raise ValueError(f"Unknown {category} catalog code: {code}") from error
-    return {"ru": ru, "ky": ky}
-
-
-def source_code(category: str, value: dict | None) -> str:
-    pair = ((value or {}).get("ru"), (value or {}).get("ky"))
-    if pair == (None, None):
-        return "unspecified"
-    for code, expected in CATALOGS[category].items():
-        if pair == expected or category == "document_type" and code == "provision" and pair == ("Положение", "Положение"):
-            return code
-    raise ValueError(f"Unmapped {category} catalog value: {pair!r}")
-
-
-def authority_codes(paths: list[dict]) -> list[str]:
-    codes = set()
-    for path in paths:
-        text = " ".join(path.get("ru", []) + path.get("ky", [])).lower()
-        if "президент" in text:
-            codes.add("president")
-        elif "жогорку кенеш" in text or "верховный совет" in text or "мыйзам чыгаруу" in text:
-            codes.add("parliament")
-        elif "кабинет министров" in text or "правительство" in text or "өкмөт" in text:
-            codes.add("cabinet")
-        elif "министер" in text or "мамлекеттик комитет" in text:
-            codes.add("ministries_and_committees")
-        elif "административ" in text:
-            codes.add("administrative_agencies")
-        elif "национальн" in text and "банк" in text or "улуттук банк" in text:
-            codes.add("national_bank")
-        elif "кенеш" in text or "кеңеш" in text or "айыл" in text or "местного самоуправления" in text:
-            codes.add("local_representative_bodies")
-        elif "иные государственные" in text or "башка мамлекеттик" in text:
-            codes.add("other_state_bodies")
-        else:
-            codes.add("other")
-    return sorted(codes) or ["other"]
--- a/backend/search/evaluate_relevance.py
+++ b/backend/search/evaluate_relevance.py
@@ -1,90 +0,0 @@
-"""Measure document search Recall@K and MRR@K against a relevance set."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-from search.minjust_opensearch import APP_VERSION
-from search.query import search_documents
-
-
-def load_queries(path: Path) -> list[dict]:
-    with path.open(encoding="utf-8") as source:
-        queries = json.load(source)
-    if not isinstance(queries, list) or not queries:
-        raise ValueError("Relevance set must be a non-empty JSON array")
-
-    seen = set()
-    for item in queries:
-        if not isinstance(item, dict) or set(item) != {
-            "id", "language", "query", "relevant_document_codes"
-        }:
-            raise ValueError("Each query must contain id, language, query and relevant_document_codes")
-        codes = item["relevant_document_codes"]
-        if (
-            not isinstance(item["id"], str)
-            or not item["id"].strip()
-            or item["id"] in seen
-            or not isinstance(item["language"], str)
-            or item["language"] not in {"ru", "ky"}
-            or not isinstance(item["query"], str)
-            or not item["query"].strip()
-            or not isinstance(codes, list)
-            or not codes
-            or any(not isinstance(code, str) or not code for code in codes)
-            or len(codes) != len(set(codes))
-        ):
-            raise ValueError(f"Invalid relevance query: {item.get('id', '<unknown>')}")
-        seen.add(item["id"])
-    return queries
-
-
-def search(base_url: str, index: str, item: dict, top_k: int) -> list[str]:
-    return search_documents(base_url, index, item["language"], item["query"], top_k)
-
-
-def evaluate(queries: list[dict], base_url: str, index: str, top_k: int) -> dict:
-    results = []
-    for item in queries:
-        retrieved = search(base_url, index, item, top_k)
-        relevant = set(item["relevant_document_codes"])
-        matches = [rank for rank, code in enumerate(retrieved, 1) if code in relevant]
-        results.append({
-            "id": item["id"],
-            "language": item["language"],
-            "query": item["query"],
-            "retrieved_document_codes": retrieved,
-            f"recall_at_{top_k}": len(relevant.intersection(retrieved)) / len(relevant),
-            f"reciprocal_rank_at_{top_k}": 1 / matches[0] if matches else 0.0,
-        })
-    return {
-        "summary": {
-            "query_count": len(results),
-            f"recall_at_{top_k}": sum(item[f"recall_at_{top_k}"] for item in results) / len(results),
-            f"mrr_at_{top_k}": sum(item[f"reciprocal_rank_at_{top_k}"] for item in results) / len(results),
-        },
-        "queries": results,
-    }
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("relevance_set", type=Path)
-    parser.add_argument("--url", default="http://127.0.0.1:9200")
-    parser.add_argument("--index", default="akyldash-fragments-v1")
-    parser.add_argument("--top-k", type=int, default=10)
-    parser.add_argument("--version", action="version", version=APP_VERSION)
-    arguments = parser.parse_args()
-    if arguments.top_k <= 0:
-        raise SystemExit("--top-k must be greater than zero")
-    result = evaluate(load_queries(arguments.relevance_set), arguments.url, arguments.index, arguments.top_k)
-    print(json.dumps(result, ensure_ascii=False, indent=2))
-    print(f"Akyldash Backend v{APP_VERSION} · Frontend — not created", file=sys.stderr)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
--- a/backend/search/minjust-fragments-index.json
+++ b/backend/search/minjust-fragments-index.json
@@ -12,7 +12,6 @@
      "schema_version": { "type": "keyword" },
      "document_code": { "type": "keyword" },
      "edition_code": { "type": "keyword" },
-      "is_current_edition": { "type": "boolean" },
      "language": { "type": "keyword" },
      "position": { "type": "integer" },
      "fragment_type": { "type": "keyword" },
@@ -22,15 +21,12 @@
      "document_name_ky": { "type": "text", "analyzer": "icu_analyzer", "fields": { "keyword": { "type": "keyword", "ignore_above": 1024 } } },
      "document_type_ru": { "type": "keyword" },
      "document_type_ky": { "type": "keyword" },
-      "document_type_code": { "type": "keyword" },
      "status_ru": { "type": "keyword" },
      "status_ky": { "type": "keyword" },
-      "status_code": { "type": "keyword" },
      "number": { "type": "keyword" },
      "date_adopted": { "type": "date", "format": "strict_date" },
      "authority_paths_ru": { "type": "keyword", "ignore_above": 2048 },
      "authority_paths_ky": { "type": "keyword", "ignore_above": 2048 },
-      "authority_codes": { "type": "keyword" },
      "source_path": { "type": "keyword", "index": false },
      "source_sha256": { "type": "keyword", "index": false },
      "text_sha256": { "type": "keyword", "index": false }
--- a/backend/search/minjust_opensearch.py
+++ b/backend/search/minjust_opensearch.py
@@ -15,9 +15,7 @@ import urllib.request
 from pathlib import Path
 from typing import Iterator

-from search.catalog import authority_codes, source_code
-
-APP_VERSION = "0.7.1"
+APP_VERSION = "0.4.1"
 LANGUAGES = {"ru", "ky"}
 DEFAULT_MAPPING = Path(__file__).with_name("minjust-fragments-index.json")

@@ -44,7 +42,7 @@ def paths(document: dict, field: str, language: str) -> list[str]:
    return [" > ".join(item[language]) for item in document.get(field, []) if item.get(language)]


-def search_document(document: dict, fragment: dict, expected: tuple[str, str, str, int], current_edition: str) -> dict:
+def search_document(document: dict, fragment: dict, expected: tuple[str, str, str, int]) -> dict:
    document_code, edition_code, language, position = expected
    fragment_id = f"document:{document_code}:edition:{edition_code}:lang:{language}:fragment:{position}"
    required = ("id", "document_code", "edition_code", "language", "position", "type", "text", "text_sha256", "source_path", "source_sha256")
@@ -66,7 +64,6 @@ def search_document(document: dict, fragment: dict, expected: tuple[str, str, st
        "schema_version": document["schema_version"],
        "document_code": document_code,
        "edition_code": edition_code,
-        "is_current_edition": edition_code == current_edition,
        "language": language,
        "position": position,
        "fragment_type": fragment["type"],
@@ -75,15 +72,12 @@ def search_document(document: dict, fragment: dict, expected: tuple[str, str, st
        "document_name_ky": localized(document.get("name"), "ky"),
        "document_type_ru": localized(document.get("type"), "ru"),
        "document_type_ky": localized(document.get("type"), "ky"),
-        "document_type_code": source_code("document_type", document.get("type")),
        "status_ru": localized(document.get("status"), "ru"),
        "status_ky": localized(document.get("status"), "ky"),
-        "status_code": source_code("status", document.get("status")),
        "number": document.get("number"),
        "date_adopted": dates.get("DateAdopted"),
        "authority_paths_ru": paths(document, "authority_paths", "ru"),
        "authority_paths_ky": paths(document, "authority_paths", "ky"),
-        "authority_codes": authority_codes(document.get("authority_paths", [])),
        "source_path": fragment["source_path"],
        "source_sha256": fragment["source_sha256"],
        "text_sha256": fragment["text_sha256"],
@@ -124,18 +118,13 @@ def bulk_pairs(
        document = read_json(directory / "document.json")
        if document.get("source_code") != directory.name:
            raise ValueError(f"Document identity does not match its path: {directory}")
-        edition_root = directory / "editions"
-        editions = [path.name for path in edition_root.iterdir() if path.is_dir()] if edition_root.is_dir() else []
-        if not editions:
-            continue
-        current_edition = max(editions, key=lambda value: (not value.isdigit(), int(value) if value.isdigit() else value))
        for fragment_path in sorted(directory.glob("editions/*/*/fragments.json")):
            edition_code, language = fragment_path.parts[-3:-1]
            values = read_json(fragment_path)
            if not isinstance(values, list):
                raise ValueError(f"Fragments must be a list: {fragment_path}")
            for position, fragment in enumerate(values, 1):
-                source = search_document(document, fragment, (directory.name, edition_code, language, position), current_edition)
+                source = search_document(document, fragment, (directory.name, edition_code, language, position))
                action = json.dumps({"index": {"_index": index, "_id": fragment["id"]}}, ensure_ascii=False, allow_nan=False)
                body = json.dumps(source, ensure_ascii=False, allow_nan=False)
                yield directory.name, f"{action}\n{body}\n".encode()
@@ -257,7 +246,6 @@ def checkpoint_state(
    cluster_uuid: str,
    index_uuid: str,
    limit: int | None,
-    alias: str | None,
 ) -> tuple[dict, str | None]:
    source = input_root.resolve()
    destination = checkpoint.resolve()
@@ -266,7 +254,7 @@ def checkpoint_state(
    manifest_sha256 = file_sha256(input_root / "manifest.sqlite3")
    if not resume:
        return {
-            "schema_version": 2,
+            "schema_version": 1,
            "url": url,
            "cluster_uuid": cluster_uuid,
            "index": index,
@@ -274,7 +262,6 @@ def checkpoint_state(
            "input": str(source),
            "manifest_sha256": manifest_sha256,
            "limit": limit,
-            "alias": alias,
            "last_document_code": None,
            "complete": False,
        }, None
@@ -289,22 +276,13 @@ def checkpoint_state(
        "input",
        "manifest_sha256",
        "limit",
-        "alias",
        "last_document_code",
        "complete",
    }
-    legacy_expected = expected - {"alias"}
-    if not isinstance(state, dict):
-        raise ValueError(f"Invalid checkpoint: {checkpoint}")
-    if set(state) == legacy_expected:
-        if state["schema_version"] != 1 or alias is not None:
-            raise ValueError(f"Legacy checkpoint does not support --alias: {checkpoint}")
-        state["schema_version"] = 2
-        state["alias"] = None
-    elif set(state) != expected:
+    if not isinstance(state, dict) or set(state) != expected:
        raise ValueError(f"Invalid checkpoint: {checkpoint}")
    if (
-        state["schema_version"] != 2
+        state["schema_version"] != 1
        or state["url"] != url
        or state["cluster_uuid"] != cluster_uuid
        or state["index"] != index
@@ -314,8 +292,6 @@ def checkpoint_state(
        raise ValueError(f"Checkpoint does not match this load: {checkpoint}")
    if state["limit"] != limit:
        raise ValueError(f"Checkpoint limit does not match --limit: {checkpoint}")
-    if state["alias"] != alias:
-        raise ValueError(f"Checkpoint alias does not match --alias: {checkpoint}")
    if state["manifest_sha256"] != manifest_sha256:
        raise ValueError("Normalized manifest changed; create a new versioned index")
    if state["complete"] is not False:
@@ -335,11 +311,8 @@ def load_bulk(
    limit: int | None = None,
    resume: bool = False,
    checkpoint: Path = Path("data/opensearch/minjust-fragments.checkpoint.json"),
-    alias: str | None = None,
 ) -> tuple[int, int]:
    base = url.rstrip("/")
-    if alias is not None and (not alias or alias == index):
-        raise ValueError("--alias must differ from --index")
    index_url = f"{base}/{urllib.parse.quote(index, safe='')}"
    if resume:
        cluster_uuid, index_uuid = opensearch_identity(base, index, index_url)
@@ -355,7 +328,6 @@ def load_bulk(
        cluster_uuid,
        index_uuid,
        limit,
-        alias,
    )
    documents = document_count(input_root, limit, start_at)
    if not resume:
@@ -391,31 +363,11 @@ def load_bulk(
        state["last_document_code"] = last_code
        write_json_atomic(checkpoint, state)
        print(f"checkpoint={last_code} fragments={fragments}", flush=True)
-    if alias:
-        switch_alias(base, index, alias)
    state["complete"] = True
    write_json_atomic(checkpoint, state)
    return documents, fragments


-def switch_alias(base: str, index: str, alias: str) -> None:
-    if not alias or alias == index:
-        raise ValueError("--alias must differ from --index")
-    result = request_json(
-        f"{base.rstrip('/')}/_aliases",
-        "POST",
-        json.dumps({
-            "actions": [
-                {"remove": {"index": "*", "alias": alias, "must_exist": False}},
-                {"add": {"index": index, "alias": alias}},
-            ]
-        }).encode(),
-        "application/json",
-    )
-    if result.get("acknowledged") is not True:
-        raise RuntimeError(f"OpenSearch did not acknowledge alias switch: {alias}")
-
-
 def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--input", type=Path, default=Path("data/minjust-normalized"))
@@ -423,7 +375,6 @@ def main() -> int:
    parser.add_argument("--index", default="akyldash-fragments-v1")
    parser.add_argument("--limit", type=int)
    parser.add_argument("--url", help="create the index and stream bounded Bulk requests instead of writing a file")
-    parser.add_argument("--alias", help="atomically point this alias at --index after a successful load")
    parser.add_argument("--mapping", type=Path, default=DEFAULT_MAPPING)
    parser.add_argument("--batch-mb", type=int, default=25)
    parser.add_argument("--resume", action="store_true", help="load into an existing index")
@@ -438,10 +389,6 @@ def main() -> int:
        raise SystemExit("--resume requires --url")
    if arguments.checkpoint and not arguments.url:
        raise SystemExit("--checkpoint requires --url")
-    if arguments.alias == "":
-        raise SystemExit("--alias must not be empty")
-    if arguments.alias is not None and not arguments.url:
-        raise SystemExit("--alias requires --url")
    if arguments.url:
        checkpoint = arguments.checkpoint or Path("data/opensearch") / f"{arguments.index}.checkpoint.json"
        documents, fragments = load_bulk(
@@ -453,7 +400,6 @@ def main() -> int:
            arguments.limit,
            arguments.resume,
            checkpoint,
-            arguments.alias,
        )
        destination = arguments.url
    else:
--- a/backend/search/query.py
+++ b/backend/search/query.py
@@ -1,90 +0,0 @@
-"""Run document searches against the local OpenSearch index."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import urllib.parse
-
-from search.minjust_opensearch import APP_VERSION, request_json
-
-
-def company_registration_clauses(language: str, query: str) -> list[dict]:
-    patterns = {
-        "ru": (r"\bкак\s+откры\w*\s+осоо\b", r"\b(порядок|процедура)\s+откры\w*\s+осоо\b", r"\bкак\s+зарегистр\w*\s+осоо\b"),
-        "ky": (r"\bжчк\s+ач\w*\s+тартиби\b", r"\bжчк\s+кантип\s+ач\w*\b"),
-    }[language]
-    if not any(re.search(pattern, query.casefold()) for pattern in patterns):
-        return []
-
-    status = {"ru": "Действует", "ky": "Күчүндө"}[language]
-    # ponytail: curated legal mapping; replace with a reviewed intent catalog when coverage expands.
-    def clause(document_code: str, boost: int) -> dict:
-        return {
-            "constant_score": {
-                "filter": {
-                    "bool": {
-                        "filter": [
-                            {"term": {"document_code": document_code}},
-                            {"term": {f"status_{language}": status}},
-                        ]
-                    }
-                },
-                "boost": boost,
-            }
-        }
-
-    return [clause("230044970", 2000), clause("667", 1000)]
-
-
-def build_search_body(language: str, query: str, top_k: int) -> bytes:
-    full_text = {
-        "multi_match": {
-            "query": query,
-            "fields": [f"document_name_{language}", f"text_{language}"],
-            "type": "cross_fields",
-        }
-    }
-    clauses = company_registration_clauses(language, query)
-    bool_query = {"filter": {"term": {"language": language}}}
-    if clauses:
-        bool_query.update({"should": [full_text, *clauses], "minimum_should_match": 1})
-    else:
-        bool_query["must"] = full_text
-    return json.dumps({
-        "size": top_k,
-        "track_total_hits": False,
-        "_source": ["document_code"],
-        "query": {"bool": bool_query},
-        "collapse": {"field": "document_code"},
-    }, ensure_ascii=False).encode()
-
-
-def search_documents(base_url: str, index: str, language: str, query: str, top_k: int) -> list[str]:
-    url = f"{base_url.rstrip('/')}/{urllib.parse.quote(index, safe='')}/_search"
-    response = request_json(url, "POST", build_search_body(language, query, top_k), "application/json")
-    try:
-        return [hit["_source"]["document_code"] for hit in response["hits"]["hits"]]
-    except (KeyError, TypeError) as error:
-        raise RuntimeError("OpenSearch search response is incomplete") from error
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("query")
-    parser.add_argument("--language", choices=("ru", "ky"), required=True)
-    parser.add_argument("--url", default="http://127.0.0.1:9200")
-    parser.add_argument("--index", default="akyldash-fragments-v1")
-    parser.add_argument("--top-k", type=int, default=10)
-    parser.add_argument("--version", action="version", version=APP_VERSION)
-    arguments = parser.parse_args()
-    if arguments.top_k <= 0:
-        raise SystemExit("--top-k must be greater than zero")
-    print(json.dumps(search_documents(arguments.url, arguments.index, arguments.language, arguments.query, arguments.top_k), ensure_ascii=False))
-    print(f"Akyldash Backend v{APP_VERSION} · Frontend — not created")
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
--- a/backend/search/relevance-set-v1.template.json
+++ b/backend/search/relevance-set-v1.template.json
@@ -1,52 +0,0 @@
-[
-  {"id": "ru-01", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-02", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-03", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-04", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-05", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-06", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-07", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-08", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-09", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-10", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-11", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-12", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-13", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-14", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-15", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-16", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-17", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-18", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-19", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-20", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-21", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-22", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-23", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-24", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ru-25", "language": "ru", "query": "", "relevant_document_codes": []},
-  {"id": "ky-01", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-02", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-03", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-04", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-05", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-06", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-07", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-08", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-09", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-10", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-11", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-12", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-13", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-14", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-15", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-16", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-17", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-18", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-19", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-20", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-21", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-22", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-23", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-24", "language": "ky", "query": "", "relevant_document_codes": []},
-  {"id": "ky-25", "language": "ky", "query": "", "relevant_document_codes": []}
-]
--- a/backend/test_minjust_opensearch.py
+++ b/backend/test_minjust_opensearch.py
@@ -9,27 +9,10 @@ from contextlib import closing
 from pathlib import Path
 from unittest.mock import patch

-from search.minjust_opensearch import bulk_batches, document_codes, export_bulk, load_bulk, request_json, switch_alias
+from search.minjust_opensearch import bulk_batches, document_codes, export_bulk, load_bulk, request_json


 class MinjustOpenSearchTest(unittest.TestCase):
-    def test_switches_alias_atomically_after_successful_load(self):
-        with patch("search.minjust_opensearch.request_json", return_value={"acknowledged": True}) as request:
-            switch_alias("http://127.0.0.1:9200/", "akyldash-fragments-v2", "akyldash-fragments-current")
-
-        self.assertEqual(request.call_args.args[:2], ("http://127.0.0.1:9200/_aliases", "POST"))
-        body = json.loads(request.call_args.args[2])
-        self.assertEqual(body["actions"][0], {"remove": {"index": "*", "alias": "akyldash-fragments-current", "must_exist": False}})
-        self.assertEqual(body["actions"][1], {"add": {"index": "akyldash-fragments-v2", "alias": "akyldash-fragments-current"}})
-
-        with self.assertRaisesRegex(ValueError, "differ"):
-            switch_alias("http://127.0.0.1:9200", "same", "same")
-        with self.assertRaisesRegex(ValueError, "differ"):
-            switch_alias("http://127.0.0.1:9200", "index", "")
-        with patch("search.minjust_opensearch.request_json", return_value={"acknowledged": False}):
-            with self.assertRaisesRegex(RuntimeError, "did not acknowledge"):
-                switch_alias("http://127.0.0.1:9200", "index", "alias")
-
    def test_exports_atomic_bulk_and_rejects_mismatched_fragment(self):
        with tempfile.TemporaryDirectory() as temporary:
            root = Path(temporary)
@@ -91,7 +74,6 @@ class MinjustOpenSearchTest(unittest.TestCase):
            self.assertEqual(len(lines), 4)
            self.assertEqual(lines[0]["index"]["_id"], "document:7:edition:10:lang:ky:fragment:1")
            self.assertIn("text_ky", lines[1])
-            self.assertTrue(lines[1]["is_current_edition"])
            self.assertNotIn("text_ru", lines[1])
            self.assertEqual(lines[3]["text_ru"], "Текст \"RU\"\nстрока")
            self.assertEqual(
@@ -109,7 +91,6 @@ class MinjustOpenSearchTest(unittest.TestCase):
                    {"cluster_uuid": "cluster-1"},
                    {"test-index": {"settings": {"index": {"uuid": "index-1"}}}},
                    {"errors": False, "items": [{"index": {}}, {"index": {}}]},
-                    {"acknowledged": True},
                ]
                self.assertEqual(
                    load_bulk(
@@ -118,40 +99,14 @@ class MinjustOpenSearchTest(unittest.TestCase):
                        "test-index",
                        maximum_bytes=4096,
                        checkpoint=checkpoint,
-                        alias="test-current",
                    ),
                    (2, 2),
                )
-                self.assertEqual(request.call_args_list[-2].args[3], "application/x-ndjson")
-                self.assertEqual(request.call_args_list[-1].args[:2], ("http://127.0.0.1:9200/_aliases", "POST"))
+                self.assertEqual(request.call_args_list[-1].args[3], "application/x-ndjson")
            state = json.loads(checkpoint.read_text(encoding="utf-8"))
            self.assertEqual(state["last_document_code"], "7")
            self.assertTrue(state["complete"])

-            legacy = state.copy()
-            legacy.pop("alias")
-            legacy["schema_version"] = 1
-            legacy["last_document_code"] = "8"
-            legacy["complete"] = False
-            checkpoint.write_text(json.dumps(legacy), encoding="utf-8")
-            with patch("search.minjust_opensearch.request_json") as request:
-                request.side_effect = [
-                    {"cluster_uuid": "cluster-1"},
-                    {"test-index": {"settings": {"index": {"uuid": "index-1"}}}},
-                ]
-                self.assertEqual(
-                    load_bulk(
-                        root / "normalized",
-                        "http://127.0.0.1:9200",
-                        "test-index",
-                        maximum_bytes=4096,
-                        resume=True,
-                        checkpoint=checkpoint,
-                    ),
-                    (1, 0),
-                )
-            self.assertEqual(json.loads(checkpoint.read_text(encoding="utf-8"))["schema_version"], 2)
-
            state["last_document_code"] = "8"
            state["complete"] = False
            checkpoint.write_text(json.dumps(state), encoding="utf-8")
@@ -161,21 +116,6 @@ class MinjustOpenSearchTest(unittest.TestCase):
                    {"test-index": {"settings": {"index": {"uuid": "index-1"}}}},
                ]
                with self.assertRaisesRegex(ValueError, "does not match"):
-                    load_bulk(
-                        root / "normalized",
-                        "http://127.0.0.1:9200",
-                        "test-index",
-                        maximum_bytes=4096,
-                        resume=True,
-                        checkpoint=checkpoint,
-                        alias="test-current",
-                    )
-            with patch("search.minjust_opensearch.request_json") as request:
-                request.side_effect = [
-                    {"cluster_uuid": "cluster-1"},
-                    {"test-index": {"settings": {"index": {"uuid": "index-1"}}}},
-                ]
-                with self.assertRaisesRegex(ValueError, "alias"):
                    load_bulk(
                        root / "normalized",
                        "http://127.0.0.1:9200",
@@ -198,13 +138,11 @@ class MinjustOpenSearchTest(unittest.TestCase):
                        limit=1,
                        resume=True,
                        checkpoint=checkpoint,
-                        alias="test-current",
                    )
            with patch("search.minjust_opensearch.request_json") as request:
                request.side_effect = [
                    {"cluster_uuid": "cluster-1"},
                    {"test-index": {"settings": {"index": {"uuid": "index-1"}}}},
-                    {"acknowledged": True},
                ]
                self.assertEqual(
                    load_bulk(
@@ -214,12 +152,10 @@ class MinjustOpenSearchTest(unittest.TestCase):
                        maximum_bytes=4096,
                        resume=True,
                        checkpoint=checkpoint,
-                        alias="test-current",
                    ),
                    (1, 0),
                )
-                self.assertTrue(all(call.args[1] == "GET" for call in request.call_args_list[:-1]))
-                self.assertEqual(request.call_args_list[-1].args[1], "POST")
+                self.assertTrue(all(call.args[1] == "GET" for call in request.call_args_list))

            state["last_document_code"] = "9"
            state["complete"] = False
@@ -237,7 +173,6 @@ class MinjustOpenSearchTest(unittest.TestCase):
                        maximum_bytes=4096,
                        resume=True,
                        checkpoint=checkpoint,
-                        alias="test-current",
                    )

            failed_checkpoint = root / "failed-checkpoint.json"
@@ -283,7 +218,6 @@ class MinjustOpenSearchTest(unittest.TestCase):
                        maximum_bytes=4096,
                        resume=True,
                        checkpoint=checkpoint,
-                        alias="test-current",
                    )

            http_error = urllib.error.HTTPError(
--- a/backend/test_search_api.py
+++ b/backend/test_search_api.py
@@ -1,68 +0,0 @@
-import json
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from search.api import Api, ApiError
-
-
-class SearchApiTest(unittest.TestCase):
-    def make_api(self, root: Path) -> Api:
-        document = root / "documents/7"
-        edition = document / "editions/10"
-        edition.mkdir(parents=True)
-        (document / "document.json").write_text(json.dumps({
-            "source_code": "7", "available_languages": ["ru"],
-            "editions": [{"source_code": "10", "available_languages": ["ru"]},],
-        }), encoding="utf-8")
-        (edition / "edition.json").write_text(json.dumps({"source_code": "10", "available_languages": ["ru"]}), encoding="utf-8")
-        (edition / "ru").mkdir()
-        (edition / "ru/content.html").write_text("<p>Текст</p>", encoding="utf-8")
-        (edition / "ru/content.txt").write_text("Текст\n", encoding="utf-8")
-        return Api("http://opensearch:9200", "current", root)
-
-    def test_search_pagination_filters_and_highlight(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            api = self.make_api(Path(temporary))
-            response = {"hits": {"hits": [{"_source": {"document_code": "7", "edition_code": "10", "document_name_ru": "Закон"}, "highlight": {"text_ru": ["<em>Закон</em>"]}}]}}
-            with patch("search.api.request_json", return_value=response) as request:
-                status, payload = api.handle("GET", "/search?q=%D0%B7%D0%B0%D0%BA%D0%BE%D0%BD&language=ru&page=2&page_size=5&status=active")
-            self.assertEqual(status, 200)
-            self.assertEqual(payload["results"][0]["snippet"], "<em>Закон</em>")
-            body = json.loads(request.call_args.args[2])
-            self.assertEqual((body["from"], body["size"]), (5, 6))
-            self.assertIn({"term": {"status_code": "active"}}, body["query"]["bool"]["filter"])
-            with self.assertRaisesRegex(ApiError, "within 10000 results"):
-                api.handle("GET", "/search?q=x&page=100&page_size=100")
-
-    def test_document_editions_openapi_and_validation(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            api = self.make_api(Path(temporary))
-            specification = api.handle("GET", "/openapi.json")[1]
-            self.assertEqual(specification["info"]["version"], "v1")
-            self.assertEqual(specification["paths"]["/documents/{code}"]["get"]["parameters"][0]["required"], True)
-            self.assertEqual(specification["paths"]["/documents/{code}/editions/{edition}"]["get"]["parameters"][1]["name"], "edition")
-            self.assertEqual(api.handle("GET", "/documents/7")[1]["current_edition"]["source_code"], "10")
-            self.assertEqual(api.handle("GET", "/documents/7/editions/10?language=ru")[1]["content"]["ru"]["text"], "Текст\n")
-            with self.assertRaisesRegex(ApiError, "q is required"):
-                api.handle("GET", "/search")
-            with self.assertRaisesRegex(ApiError, "date_from must be an ISO date"):
-                api.handle("GET", "/search?q=x&date_from=tomorrow")
-            with self.assertRaisesRegex(ApiError, "document not found"):
-                api.handle("GET", "/documents/%2E%2E")
-
-    def test_filters_count_documents_and_return_bilingual_labels(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            api = self.make_api(Path(temporary))
-            response = {"aggregations": {name: {"buckets": [{"key": "law" if name == "document_types" else "active" if name == "statuses" else "parliament", "documents": {"value": 3}}]} for name in ("document_types", "statuses", "authorities")}}
-            with patch("search.api.request_json", return_value=response) as request:
-                payload = api.handle("GET", "/search/filters?language=ky")[1]
-            self.assertEqual(payload["document_types"][0], {"code": "law", "labels": {"ru": "Закон", "ky": "Мыйзам"}, "count": 3})
-            body = json.loads(request.call_args.args[2])
-            self.assertIn("terms", body["aggs"]["document_types"])
-            self.assertEqual(body["query"], {"term": {"is_current_edition": True}})
-
-
-if __name__ == "__main__":
-    unittest.main()
--- a/backend/test_search_api_opensearch.py
+++ b/backend/test_search_api_opensearch.py
@@ -1,37 +0,0 @@
-import json
-import os
-import unittest
-import uuid
-from pathlib import Path
-
-from search.api import Api
-from search.minjust_opensearch import DEFAULT_MAPPING, request_json
-
-
-@unittest.skipUnless(os.getenv("AKYLDASH_OPENSEARCH_URL"), "set AKYLDASH_OPENSEARCH_URL to run against local OpenSearch")
-class SearchApiOpenSearchTest(unittest.TestCase):
-    def test_current_editions_filters_and_catalogs(self):
-        base_url = os.environ["AKYLDASH_OPENSEARCH_URL"].rstrip("/")
-        index = f"akyldash-api-test-{uuid.uuid4().hex}"
-        request_json(f"{base_url}/{index}", "PUT", DEFAULT_MAPPING.read_bytes(), "application/json")
-        try:
-            documents = [
-                {"document_code": "1", "edition_code": "1", "is_current_edition": False, "language": "ru", "position": 1, "fragment_type": "paragraph", "text_ru": "historic", "document_name_ru": "Old law", "document_type_ru": "Закон", "document_type_ky": "Мыйзам", "document_type_code": "law", "status_ru": "Утратил силу", "status_ky": "Күчүн жоготту", "status_code": "repealed", "date_adopted": "2020-01-01", "authority_paths_ru": ["Парламент"], "authority_paths_ky": ["Парламент"], "authority_codes": ["parliament"]},
-                {"document_code": "1", "edition_code": "2", "is_current_edition": True, "language": "ru", "position": 1, "fragment_type": "paragraph", "text_ru": "needle", "document_name_ru": "Current law", "document_type_ru": "Закон", "document_type_ky": "Мыйзам", "document_type_code": "law", "status_ru": "Действует", "status_ky": "Күчүндө", "status_code": "active", "date_adopted": "2021-01-01", "authority_paths_ru": ["Парламент"], "authority_paths_ky": ["Парламент"], "authority_codes": ["parliament"]},
-                {"document_code": "2", "edition_code": "1", "is_current_edition": True, "language": "ru", "position": 1, "fragment_type": "paragraph", "text_ru": "needle", "document_name_ru": "Current decree", "document_type_ru": "Указ", "document_type_ky": "Жарлык", "document_type_code": "decree", "status_ru": "Действует", "status_ky": "Күчүндө", "status_code": "active", "date_adopted": "2022-01-01", "authority_paths_ru": ["Президент"], "authority_paths_ky": ["Президент"], "authority_codes": ["president"]},
-            ]
-            for number, document in enumerate(documents):
-                request_json(f"{base_url}/{index}/_doc/{number}", "PUT", json.dumps(document).encode(), "application/json")
-            request_json(f"{base_url}/{index}/_refresh", "POST", None, "application/json")
-            api = Api(base_url, index, Path("."))
-            self.assertEqual(api.handle("GET", "/search?q=historic")[1]["results"], [])
-            filtered = api.handle("GET", "/search?q=needle&document_type=law")[1]
-            self.assertEqual([result["code"] for result in filtered["results"]], ["1"])
-            filters = api.handle("GET", "/search/filters")[1]
-            self.assertEqual({item["count"] for item in filters["statuses"]}, {2})
-        finally:
-            request_json(f"{base_url}/{index}", "DELETE", None, "application/json")
-
-
-if __name__ == "__main__":
-    unittest.main()
--- a/backend/test_search_relevance.py
+++ b/backend/test_search_relevance.py
@@ -1,76 +0,0 @@
-import json
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from search.evaluate_relevance import evaluate, load_queries
-from search.query import build_search_body
-
-
-class SearchRelevanceTest(unittest.TestCase):
-    def test_loads_queries_and_calculates_document_metrics(self):
-        queries = [
-            {
-                "id": "ru-01",
-                "language": "ru",
-                "query": "трудовой договор",
-                "relevant_document_codes": ["7", "8"],
-            },
-            {
-                "id": "ky-01",
-                "language": "ky",
-                "query": "эмгек келишими",
-                "relevant_document_codes": ["9"],
-            },
-        ]
-        with tempfile.TemporaryDirectory() as temporary:
-            path = Path(temporary) / "queries.json"
-            path.write_text(json.dumps(queries, ensure_ascii=False), encoding="utf-8")
-            loaded = load_queries(path)
-
-        with patch("search.evaluate_relevance.search_documents", side_effect=[["7", "10", "8"], ["10", "9"]]):
-            result = evaluate(loaded, "http://127.0.0.1:9200", "test", 10)
-
-        self.assertEqual(result["summary"], {"query_count": 2, "recall_at_10": 1.0, "mrr_at_10": 0.75})
-        self.assertEqual(result["queries"][0]["reciprocal_rank_at_10"], 1.0)
-        body = json.loads(build_search_body("ru", "трудовой договор", 10))
-        self.assertFalse(body["track_total_hits"])
-        self.assertEqual(body["collapse"], {"field": "document_code"})
-        self.assertEqual(body["query"]["bool"]["must"]["multi_match"]["type"], "cross_fields")
-
-    def test_company_registration_intent_boosts_current_documents(self):
-        for language, query, status in (
-            ("ru", "как открыть ОсОО", "Действует"),
-            ("ky", "ЖЧК ачуу тартиби", "Күчүндө"),
-        ):
-            body = json.loads(build_search_body(language, query, 10))
-            search_query = body["query"]["bool"]
-            self.assertEqual(search_query["minimum_should_match"], 1)
-            boosts = [clause["constant_score"] for clause in search_query["should"][1:]]
-            self.assertEqual([item["boost"] for item in boosts], [2000, 1000])
-            self.assertEqual(
-                [item["filter"]["bool"]["filter"][0]["term"]["document_code"] for item in boosts],
-                ["230044970", "667"],
-            )
-            self.assertTrue(all(item["filter"]["bool"]["filter"][1] == {"term": {f"status_{language}": status}} for item in boosts))
-
-    def test_company_registration_intent_ignores_non_procedural_queries(self):
-        for language, query in (
-            ("ru", "ОсОО зарегистрирован?"),
-            ("ru", "кто зарегистрировал ОсОО"),
-            ("ru", "как открыть счет ОсОО"),
-            ("ru", "как открыть филиал ОсОО"),
-            ("ru", "как создать договор для ОсОО"),
-            ("ru", "порядок создания логотипа ОсОО"),
-            ("ky", "ЖЧК ачык маалымат"),
-            ("ky", "ЖЧК кантип банк эсебин ачуу"),
-            ("ky", "ЖЧК кантип келишим түзүү"),
-            ("ky", "ЖЧК кантип логотип түзүү"),
-        ):
-            body = json.loads(build_search_body(language, query, 10))
-            self.assertNotIn("should", body["query"]["bool"])
-
-
-if __name__ == "__main__":
-    unittest.main()
--- a/docs/README.md
+++ b/docs/README.md
@@ -6,10 +6,6 @@
  правила работы с данными.
 - [План frontend поисковой СПС](product/frontend-search-sps-plan.md) — границы
  MVP, зависимости и спринты.
- [Готовность к проектированию frontend](product/frontend-design-readiness-plan.md) —
-  обязательные работы и критерии перехода к frontend.
- [План интерфейса оценки поисковой выдачи](product/search-relevance-review-interface-plan.md) —
-  внутренний инструмент сбора оценок юристов для настройки OpenSearch.
 - [Задание по нормализации документов](product/minjust-document-normalization-agent-task.md) —
  требования и критерии приёмки нормализатора ЦБД Минюста КР.

@@ -37,4 +33,4 @@

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/decisions/001-telegram-workspace-mvp.md
+++ b/docs/decisions/001-telegram-workspace-mvp.md
@@ -78,4 +78,4 @@ Telegram позволяет запретить пользователям отп

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/operations/project-status.md
+++ b/docs/operations/project-status.md
@@ -5,7 +5,7 @@

 - Telegram-бот: `0.2.2`
 - Telegram-бот на Synology: `0.2.1`
- Backend: `0.7.1`
+- Backend: `0.4.1`
 - Frontend: не создан

 ## Краткий итог
@@ -77,6 +77,16 @@
 - Полный проход завершён: 209 958 документов нормализованы без ошибок.
 - Контрольная выборка RU/KY прошла проверки текста, фрагментов, ID и SHA-256.
 - Добавлены строгий mapping и атомарный Bulk NDJSON-экспорт для OpenSearch.
+- PR #10 слит в `main` merge-коммитом `3873954`.
+- Локальный OpenSearch 3.7.0 с `analysis-icu` запущен через
+  `deploy/local-opensearch/compose.yaml`; данные хранятся в
+  `data/opensearch-node`.
+- Индекс `akyldash-fragments-v1` полностью построен: 56 295 965 фрагментов,
+  состояние `green`, размер около 16 ГБ.
+- Потоковый загрузчик использует ограниченные Bulk-пакеты, атомарный checkpoint,
+  безопасный resume, retry/backoff и подробную диагностику ошибок.
+- Smoke-поиск по RU и KY успешно выполнен; наблюдаемое время ответа составляло
+  20–22 мс.

 ### Развёртывание

@@ -90,9 +100,16 @@

 ### Развёртывание и сопровождение

- Docker-конфигурация развёртывания не хранится в репозитории.
+- Production-конфигурация Docker не хранится в репозитории; добавлен только
+  локальный стенд OpenSearch без security plugin и replicas.
 - Не настроен CI/CD.

+### Поиск
+
+- Не подготовлена эталонная выборка из 50–100 реальных RU/KY-запросов.
+- Не измерены baseline-метрики качества поиска и не настроено ранжирование.
+- Поисковый API и frontend ещё не созданы.
+
 ### Хранилище

 - PostgreSQL не подключён; первая версия использует SQLite.
@@ -122,32 +139,33 @@

 ## Следующий этап

-### Фиксация MVP и проверка полного цикла
+### Оценка качества поиска

 Рекомендуемый порядок:

-1. Настроить резервное копирование `/volume1/docker/akyldash/data`.
-2. Зафиксировать состав MVP с командой и закрыть тему `MVP`.
-3. Провести одно реальное обсуждение с ответами, правками и вложением.
-4. Экспортировать обсуждение и вручную проанализировать Markdown в ChatGPT.
-5. Вернуть подтверждённый итог в тему `Решения` и зафиксировать его в Git/Gitea.
-6. Записать обнаруженные неудобства и только после этого выбирать следующую доработку.
+1. Создать Gitea Issue для relevance set v1.
+2. Подготовить 50 запросов: 25 RU и 25 KY, с ожидаемыми документами и оценками
+   релевантности.
+3. Выполнить запросы по `akyldash-fragments-v1` и зафиксировать baseline
+   Recall@10 и MRR.
+4. Настроить запрос и веса полей по фактическим ошибкам выдачи.
+5. После приемлемого baseline проектировать поисковый API; frontend до этого не
+   начинать.
+
+### Точка продолжения после перезапуска Codex
+
+- Рабочая ветка: `docs/project-status-handoff`, создана от актуального `main`.
+- Актуальный `main`: `3873954`, PR #10 уже слит.
+- Контейнер OpenSearch и полный индекс находятся локально; пересоздавать индекс
+  не требуется.
+- Ближайшее действие: оформить relevance set v1 как задачу в Gitea.
+- Локальные `mail.jpg` и `synology-containers.jpg` не отслеживаются Git и должны
+  остаться нетронутыми.

 ## История изменений статуса

-### 2026-08-18
-
- Оценщик поиска использует `cross_fields` для совместного сопоставления
-  названия и текста документа.
- На размеченном наборе из 50 запросов Recall@10 вырос с `0.23` до `0.30`,
-  MRR@10 — с `0.1854` до `0.2272`.
- Версия backend обновлена до `0.5.1`.
-
 ### 2026-08-14

- Добавлены шаблон relevance set v1 и воспроизводимый расчёт Recall@K/MRR@K.
- Версия backend обновлена до `0.5.0`.
-
 - Полный локальный индекс содержит 56 295 965 фрагментов и успешно отвечает на
  RU/KY-запросы.
 - Добавлены атомарный checkpoint и безопасное продолжение прерванной загрузки
@@ -234,4 +252,4 @@

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/operations/telegram-workspace-plan.md
+++ b/docs/operations/telegram-workspace-plan.md
@@ -398,4 +398,4 @@ Git сохраняет актуальную версию

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/product/frontend-design-readiness-plan.md
+++ b/docs/product/frontend-design-readiness-plan.md
@@ -1,126 +0,0 @@
-# Готовность к проектированию frontend
-
-Этот документ определяет обязательный результат до начала проектирования и
-разработки пользовательского интерфейса. Он дополняет
-[план frontend поисковой СПС](frontend-search-sps-plan.md): тот описывает MVP и
-спринты frontend, этот — критерий перехода к ним.
-
-## Правило перехода
-
-Проектирование frontend начинается, когда выполнены все обязательные пункты
-этого плана и пройден финальный readiness gate. До этого не создаются
-`frontend/`, макеты, UI-компоненты или mock-данные, заменяющие неготовый
-backend-контракт.
-
-Вне этого этапа остаются аккаунты, уведомления, RAG, судебная практика и
-внешние коммерческие сервисы.
-
-## 1. Данные и поисковый индекс
-
-### Результат
-
-В локальном OpenSearch доступен воспроизводимо собранный корпус актуальных
-редакций ЦБД Минюста КР, пригодный для поиска на русском и кыргызском языках.
-
-### Обязательные работы
-
-1. Подтвердить для каждого индексируемого документа наличие канонических
-   реквизитов: код, редакция, язык, статус, тип, орган, дата, номер, название
-   и ссылка на официальный источник.
-2. Зафиксировать правила для документов без текста и одноязычных редакций:
-   они не скрываются и не получают выдуманный перевод.
-3. Проверить versioned-индекс, mapping, анализаторы RU/KY, полноту актуальных
-   редакций и процедуру безопасной переиндексации с переключением alias.
-4. Описать и выполнить воспроизводимый сценарий обновления:
-   выгрузка → нормализация → новый индекс → проверка → переключение alias.
-
-### Критерий приёмки
-
-Команда может повторить обновление на чистом локальном окружении, проверить
-количество документов и фрагментов, а затем безопасно переключить поисковый
-alias без смешивания старого и нового корпуса.
-
-## 2. Relevance set и качество поиска
-
-### Результат
-
-Есть замороженный набор `relevance set v1` из 50 практических запросов:
-минимум 25 на русском и 25 на кыргызском языках.
-
-### Обязательные работы
-
-1. Заполнить рабочую копию из `backend/search/relevance-set-v1.template.json`
-   естественными формулировками пользователей и подтверждёнными
-   `document_code` релевантных действующих актов.
-2. Проверить каждый запрос по официальной ЦБД и локальному индексу; не
-   включать запросы без установленного эталонного результата.
-3. Провести независимую вторую проверку языка, формулировки и полного списка
-   кодов. Спорные результаты не включать до согласования.
-4. После проверки сохранить неизменяемую копию набора и baseline
-   `Recall@10`/`MRR@10`; новые правила ранжирования оценивать только сравнением
-   с этим baseline.
-5. Отдельно проверить распространённые сокращения, опечатки и запросы о
-   практическом действии. Правило принимается, только если улучшает
-   подтверждённые запросы и не создаёт ложных срабатываний в негативных
-   сценариях.
-
-### Критерий приёмки
-
-Оценщик проходит на полном наборе, выводит метрики и выдачу для каждого
-запроса; baseline и результаты его повторного запуска воспроизводимы.
-
-## 3. Справочники и контракт API
-
-### Результат
-
-Frontend получает все юридически значимые данные через версионированный
-OpenAPI-контракт, а не реконструирует их из текста фрагментов.
-
-### Обязательные работы
-
-1. Утвердить справочники v1: типы документов, органы принятия, статусы,
-   уровни действия и темы. Для каждого значения определить стабильный код и
-   подписи RU/KY.
-2. Реализовать и описать OpenAPI для:
-   - `GET /search` — запрос, язык, фильтры, сортировка, серверная пагинация,
-     выдержка и подсветка;
-   - `GET /search/filters` — допустимые значения фильтров;
-   - `GET /documents/{code}` — карточка актуального документа;
-   - `GET /documents/{code}/editions` и
-     `GET /documents/{code}/editions/{edition}` — редакции и их содержимое.
-3. Зафиксировать единые ответы для пустой выдачи, неизвестного документа,
-   недоступной редакции и ошибки upstream; для документов с одним языком
-   вернуть доступные языки явно.
-4. Добавить контрактные и интеграционные проверки API на локальном OpenSearch:
-   поиск, фильтры, пагинация, сортировка, документ, редакции и одноязычные
-   акты.
-
-### Критерий приёмки
-
-OpenAPI опубликован вместе с backend, тестовый клиент получает реальные данные
-по всем endpoint без mock-слоя, а результаты поиска открывают актуальный
-документ и выбранную редакцию.
-
-## 4. Финальный readiness gate
-
-Перед началом frontend выполнить и зафиксировать один сквозной сценарий:
-
-1. Обновить корпус из официальной ЦБД.
-2. Нормализовать данные и собрать новый versioned-индекс.
-3. Прогнать проверки индекса и relevance baseline.
-4. Переключить alias на проверенный индекс.
-5. Выполнить API-сценарии поиска, фильтрации, просмотра документа и редакции
-   на RU, KY и одноязычном документе.
-
-Gate считается пройденным, если все проверки успешны, зафиксированы версии
-backend и индекса, опубликованы известные ограничения и назначен ответственный
-за юридическую проверку relevance set.
-
-## Порядок issues
-
-1. Собрать и независимо проверить relevance set v1.
-2. Завершить проверку полноты данных и воспроизводимую переиндексацию с alias.
-3. Утвердить справочники v1.
-4. Реализовать OpenAPI и интеграционные проверки.
-5. Провести финальный readiness gate и только затем открыть задачу на
-   проектирование frontend.
--- a/docs/product/frontend-search-sps-plan.md
+++ b/docs/product/frontend-search-sps-plan.md
@@ -258,4 +258,4 @@ runtime-зависимостями frontend. Регистрация в стор

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/product/minjust-document-normalization-agent-task.md
+++ b/docs/product/minjust-document-normalization-agent-task.md
@@ -214,4 +214,4 @@ python3 backend/normalization/minjust_cbd.py

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/product/project-overview.md
+++ b/docs/product/project-overview.md
@@ -44,4 +44,4 @@

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/docs/product/search-catalog-v1.md
+++ b/docs/product/search-catalog-v1.md
@@ -1,78 +0,0 @@
-# Справочники Search API v1
-
-Статус: утверждённый контракт для Search API v1.
-
-`code` — неизменяемый идентификатор, независимый от языка. Клиент хранит и
-передаёт только `code`; русское и кыргызское названия являются подписями и могут
-исправляться без изменения кода.
-
-## Типы документов
-
-| Code | RU | KY |
-| --- | --- | --- |
-| `constitution` | Конституция | Конституция |
-| `constitutional_law` | Конституционный Закон | Конституциалык Мыйзам |
-| `code` | Кодекс | Кодекс |
-| `law` | Закон | Мыйзам |
-| `decree` | Указ | Жарлык |
-| `resolution` | Постановление | Токтом |
-| `order` | Распоряжение | Распоряжение |
-| `instruction` | Инструкция | Инструкция |
-| `rules` | Правила | Правила |
-| `procedure` | Порядок | Порядок |
-| `provision` | Положение | Жобо |
-| `regulation` | Регламент | Регламент |
-| `charter` | Устав | Жобо (Устав) |
-| `program` | Программа | Программа |
-| `plan` | План | План |
-| `strategy` | Стратегия | Стратегия |
-| `concept` | Концепция | Концепция |
-| `doctrine` | Доктрина | Доктрина |
-| `agreement` | Соглашение | Соглашение |
-| `declaration` | Декларация | Декларация |
-| `registry` | Реестр | Реестр |
-| `norms` | Нормативы | Нормативы |
-| `model` | Модель | Модель |
-| `matrix` | Матрица | Матрица |
-| `study` | Исследование | Исследование |
-| `report` | Доклад | Доклад |
-| `principles` | Основные принципы | Основные принципы |
-
-## Статусы
-
-| Code | RU | KY |
-| --- | --- | --- |
-| `active` | Действует | Күчүндө |
-| `repealed` | Утратил силу | Күчүн жоготту |
-| `unspecified` | Не указан | Көрсөтүлгөн эмес |
-
-## Органы принятия
-
-Орган содержит два уровня: стабильную группу и конкретный орган. В v1 группы
-следующие:
-
-| Code | RU | KY |
-| --- | --- | --- |
-| `president` | Президент | Президент |
-| `parliament` | Органы законодательной власти | Мыйзам чыгаруу бийлик органдары |
-| `cabinet` | Правительство и Кабинет Министров | Өкмөт жана Министрлер Кабинети |
-| `ministries_and_committees` | Министерства и государственные комитеты | Министрликтер жана мамлекеттик комитеттер |
-| `administrative_agencies` | Административные ведомства | Административдик ведомстволор |
-| `national_bank` | Национальный банк | Улуттук банк |
-| `other_state_bodies` | Иные государственные органы | Башка мамлекеттик органдар |
-| `local_representative_bodies` | Представительные органы местного самоуправления | Жергиликтүү өз алдынча башкаруунун өкүлчүлүктүү органдары |
-| `other` | Прочие органы | Башка органдар |
-
-Конкретные министерства, муниципальные и айылные кенеши не получают ID из
-подписи: в выгрузке ЦБД их поле `Code` часто равно `null`. До появления
-первичного неизменяемого идентификатора API v1 выдаёт и принимает только код
-группы органа. Полный каталог конкретных органов — отдельная версия (`v2`),
-когда источник предоставит такие идентификаторы либо будет утверждён вручную
-поддерживаемый реестр.
-
-## Правила совместимости
-
- Код из этой таблицы нельзя переиспользовать и нельзя менять его значение.
- Новое значение добавляется только новой записью; удалённое остаётся доступно
-  для старых документов.
- Запрос с неизвестным кодом возвращает `400`.
--- a/docs/product/search-relevance-review-interface-plan.md
+++ b/docs/product/search-relevance-review-interface-plan.md
@@ -1,146 +0,0 @@
-# План внутреннего интерфейса оценки поисковой выдачи
-
-## Цель
-
-Создать закрытую лабораторию релевантности: юрист оценивает фактическую выдачу
-нашего OpenSearch по практическим запросам. Цель — улучшать собственное
-ранжирование, а не воспроизводить алгоритм сайта Минюста КР.
-
-ЦБД Минюста используется как официальный источник текста, реквизитов, статуса
-и редакции акта. Порядок результатов и оценка их полезности определяются в
-нашем сервисе.
-
-Это внутренний рабочий инструмент, а не публичный frontend MVP. Он не включает
-регистрацию, личные кабинеты, публичный дизайн, сложные фильтры или сравнение
-редакций.
-
-## Сценарий юриста
-
-1. Указать поисковый запрос и язык.
-2. Получить первые 10–20 результатов в точном порядке OpenSearch.
-3. Увидеть позицию каждого результата: `#1`, `#2` и далее.
-4. Открыть выбранный документ по клику на название в правой панели страницы.
-5. Поставить каждому просмотренному результату оценку и комментарий.
-6. Сохранить снимок выдачи и оценок.
-7. Передать накопленные записи на анализ ранжирования.
-
-## Оценка результата
-
-| Балл | Значение |
-| ---: | --- |
-| 0 | Нерелевантен: совпали слова, но акт не отвечает на вопрос. |
-| 1 | Косвенно полезен: относится к теме, но прямого ответа нет. |
-| 2 | Частично полезен: отвечает не полностью или требует другого акта. |
-| 3 | Прямо и достаточно отвечает на запрос. |
-
-Оценка относится к отдельному документу, а не ко всей выдаче. Результат без
-оценки считается непросмотренным, а не нерелевантным.
-
-## Интерфейс
-
-Рекомендуемый экран — две панели.
-
- Вверху: поле запроса, переключатель RU/KY, выбор числа результатов и кнопка
-  «Найти».
- Слева: карточки результатов в порядке выдачи. Карточка содержит позицию,
-  название, тип, статус, дату, номер и фрагмент текста.
- Справа: заголовок, реквизиты, очищенный HTML выбранной редакции и ссылка на
-  официальный источник.
- В карточке: кнопки оценки `0`, `1`, `2`, `3` и раскрываемое поле
-  комментария.
- Внизу: имя или псевдоним проверяющего, общий комментарий и кнопка
-  «Сохранить оценку».
-
-Правая панель предпочтительнее popup: она не блокируется браузером, сохраняет
-контекст выдачи и работает на одном экране с оценкой.
-
-До сохранения черновик хранится в `localStorage`. После успешного сохранения
-интерфейс показывает ID записи и время сохранения.
-
-## Backend и хранение
-
-Использовать существующие endpoint:
-
- `GET /search` — получить ранжированный список результатов;
- `GET /documents/{code}/editions/{edition}` — получить текст выбранной
-  редакции.
-
-Добавить два endpoint:
-
- `POST /search-reviews` — валидирует и сохраняет оценку;
- `GET /search-reviews/export` — отдаёт накопленные записи в JSON.
-
-Для первой версии достаточно отдельной SQLite-базы. Это стандартная библиотека
-Python, данные переживают перезапуск и легко выгружаются для анализа. Доступ к
-интерфейсу и всем endpoint `search-reviews`, включая экспорт, должен быть
-ограничен локальной сетью/VPN или аутентификацией reverse proxy.
-
-Одна запись представляет один сохранённый поисковый сеанс:
-
-| Поле | Назначение |
-| --- | --- |
-| `id`, `created_at` | Идентификатор и время сохранения. |
-| `reviewer` | Имя или псевдоним проверяющего. |
-| `query`, `language` | Исходный запрос и язык поиска. |
-| `index_name`, `algorithm_version` | Версия индекса и алгоритма на момент оценки. |
-| `top_result_code` | Код документа в позиции `#1`. |
-| `results_json` | Снимок результатов в исходном порядке с оценками и комментариями. |
-| `overall_comment` | Общий комментарий к выдаче. |
-
-В `results_json` для каждого результата сохраняются: `rank`, `document_code`,
-`edition_code`, название, реквизиты, фрагмент, оценка и комментарий. Снимок
-выдачи обязателен: после изменения алгоритма можно будет восстановить именно
-тот результат, который видел юрист.
-
-## Правила сохранения
-
- Запрос не пустой, не длиннее 500 символов.
- Оценка может быть только целым числом от 0 до 3 либо отсутствовать у
-  непросмотренного результата.
- Комментарии имеют ограничение длины; пользовательские значения не вставляются
-  в HTML.
- `GET /search` возвращает краткоживущий HMAC-подписанный снимок выдачи:
-  запрос, язык, индекс, результаты и их позиции. `POST /search-reviews`
-  принимает этот снимок и только оценки с комментариями. Сервер проверяет
-  подпись и срок, самостоятельно формирует `results_json` и отклоняет оценки
-  для отсутствующих либо подменённых позиций и документов.
- Нельзя передавать персональные данные или закрытые материалы в комментариях.
-
-## Анализ данных
-
-Экспорт должен содержать исходный JSON-снимок, чтобы его можно было обработать
-скриптом или открыть в табличном инструменте. Первый отчёт строит:
-
- среднюю оценку для каждой позиции выдачи;
- долю результатов с оценкой `3` в top-1, top-3 и top-10;
- запросы, где нет результатов с оценкой `2` или `3`;
- документы, которые часто получают низкую оценку в первых позициях;
- комментарии для ручного разбора ошибок.
-
-Сырые оценки не должны автоматически менять веса поиска. Сначала команда
-разбирает причины: анализатор, синонимы, статус, отсутствие документа,
-неправильная формулировка запроса или юридическая неоднозначность.
-
-## Этапы реализации
-
-1. Утвердить шкалу 0–3, обязательность имени проверяющего и правила доступа.
-2. Добавить SQLite-хранилище, валидацию, сохранение и JSON-экспорт.
-3. Добавить статическую внутреннюю страницу в существующий Python-сервер, без
-   Next.js и отдельного публичного приложения.
-4. Подключить поиск, правую панель документа, черновик и сохранение.
-5. Добавить минимальные backend-проверки сохранения, повторного запуска,
-   экспорта и недопустимых оценок.
-6. Провести ручный прогон на десяти русскоязычных практических запросах с
-   двумя юристами.
-7. На собранных записях настроить OpenSearch и повторить тот же набор запросов.
-
-## Критерий готовности
-
-Юрист вводит запрос, видит порядок выдачи, открывает документ, выставляет
-оценки и комментарии, сохраняет их. Экспорт содержит запрос, язык, документ
-на позиции `#1`, полный порядок результатов, оценки, комментарии и версию
-индекса. Данные можно сравнить до и после изменения алгоритма.
-
---
-
-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
--- a/docs/team/ai-skills-for-beginners.md
+++ b/docs/team/ai-skills-for-beginners.md
@@ -180,4 +180,4 @@

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан
--- a/tools/telegram-bot/README.md
+++ b/tools/telegram-bot/README.md
@@ -48,4 +48,4 @@ python3 -m unittest -v

 ---

-Акылдаш · Telegram-бот v0.2.2 · Backend v0.7.1 · Frontend — не создан
+Акылдаш · Telegram-бот v0.2.2 · Backend v0.4.1 · Frontend — не создан