Blame for eval/judge.py

"""Судья: модель сверяет выдачу системы с эталоном и рубрикой задачи и ищет галлюцинации и искажения.



Судья слепой: он не знает, какая система ответила, и видит только просьбу человека, сведения о материалах, эталонный

ответ, рубрику, запрещённые утверждения и выдачу системы (ответ на каждое сообщение человека и текст выданных файлов).

Каждый пункт рубрики он отмечает «верно / частично / неверно / нет в ответе»: по этим отметкам отчёт считает точность

(верное среди сказанного по пунктам) и полноту (доля пунктов, закрытых верно). Вердикт он подкрепляет дословной цитатой

из выдачи; галлюцинацию тоже цитатой. Цитаты сверяются кодом: вердикт с цитатой, которой в выдаче нет, как и «частично»

или «неверно» без цитаты, становится «нет в ответе»; галлюцинация без найденной цитаты отбрасывается. Так судья не может

ни засчитать то, чего нет, ни приписать системе то, чего она не писала. «Верно» без цитаты судья ставит только пункту о

том, чего в выдаче быть не должно.



Галлюцинация — утверждение выдачи, которое противоречит эталону или материалам (искажение), или факт, взятый ниоткуда

(выдумка). Материалов человека целиком судья не видит: их бывают сотни файлов. Поэтому каждая найденная им галлюцинация, кроме

запрещённых утверждений задачи, проходит второй проход: поиск по словам и числам утверждения находит отрывки материалов,

и модель, видя утверждение в его месте выдачи, решает, подтверждают ли они его. Отрывки — первоисточник, эталон — мерило

ответа, а не перечень всего верного. Галлюцинация снимается, только если модель привела дословную цитату из

отрывка или эталона и код нашёл её там; иначе она остаётся. Верное по материалам, но не вошедшее в эталон, так не

становится галлюцинацией, а неподтверждённое не проходит.



Модель — та же, что у сравниваемых систем (Qwen3.8-27B на vLLM), через OpenAI-совместимый API; ответ — строго по

JSON-схеме (guided decoding), температура 0.



    python judge.py <tasks.jsonl> <папка прогона системы> [--base-url http://host:8000/v1] [--model qwen3.8-27b] [--only <задача> …]



Подключение к модели без ключей берётся из окружения: JUDGE_BASE_URL, JUDGE_MODEL, JUDGE_API_KEY, а без них из

WORKPERMIT_MODEL_URL, WORKPERMIT_MODEL, WORKPERMIT_MODEL_KEY, общих с прогонщиком DeepSeek Harness: судья — та же модель,

что у систем. Внутри контейнера оценки адрес localhost ведёт на машину, где запущен контейнер (host.docker.internal).

Результат пишется в ``<задача>/judge.json`` рядом с ``record.json``. Весь прогон одной командой оценивает ``evaluate.py``.

"""

from __future__ import annotations

import argparse
import datetime
import http.client
import json
import math
import os
import re
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path

sys.path.insert(0, str(Path(__file__).parent))
from checks import Output, normalize, numbers, rubric_items  # noqa: E402
from extract import extract  # noqa: E402

MAX_FILE_CHARS = 40_000
MAX_OUTPUT_CHARS = 100_000
JUDGE_ATTEMPTS = 3

SCHEMA = {
    "type": "object",
    "properties": {
        "rubric": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "item": {"type": "integer"},
                    "reasoning": {"type": "string"},
                    "quote": {"type": "string"},
                    "verdict": {"type": "string", "enum": ["yes", "partial", "wrong", "missing"]},
                },
                "required": ["item", "reasoning", "quote", "verdict"],
            },
        },
        "fabrications": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "quote": {"type": "string"},
                    "why": {"type": "string"},
                    "must_not": {"type": "integer"},
                },
                "required": ["quote", "why", "must_not"],
            },
        },
    },
    "required": ["rubric", "fabrications"],
}

SYSTEM = """Ты — строгий и беспристрастный проверяющий в бенчмарке рабочих задач. Тебе показывают просьбу человека, сведения

о его материалах, вопросы системы с ответами человека, если она спрашивала, эталонный ответ, рубрику, список

запрещённых утверждений и выдачу системы — её ответ (если сообщений несколько, ответ на каждое) и текст выданных

файлов. Какая система ответила, неизвестно и не важно.



Правила:

1. Оценивай только выдачу системы. Эталон — мерило, а не образец формулировок: верный ответ другими словами — «yes».

2. По каждому пункту рубрики: сначала кратко рассуждай, потом приведи дословную цитату из выдачи, на которой основан

   вердикт (короткий фрагмент, скопированный символ в символ), потом вердикт:

   «yes» — пункт выполнен полностью и верно;

   «partial» — выполнен частично или с неточностью;

   «wrong» — по пункту сказано неверное: значение, вывод или источник противоречат эталону или материалам;

   «missing» — по пункту в выдаче ничего нет, цитата пустая.

   Без цитаты «yes», «partial» и «wrong» не ставь. Если пункт требует, чтобы чего-то в выдаче НЕ было: этого нет — «yes»

   с пустой цитатой, это есть — «wrong» с цитатой.

3. Галлюцинации и искажения: перечисли утверждения выдачи, которые противоречат эталону или материалам, или факты (числа,

   имена, реквизиты, нормы, источники), взятые ниоткуда. Для каждого — дословная цитата и почему это галлюцинация. Если

   оно совпадает с пунктом списка запрещённых утверждений, укажи его номер в must_not, иначе 0. Разумные допущения, прямо

   названные допущениями, — не галлюцинация. Не считай галлюцинацией то, что верно по материалам, даже если этого нет в

   эталоне.

Ответ — строго JSON по схеме."""


def _materials_summary(task: dict) -> str:
    lines = []
    for i, turn in enumerate(task.get("turns", []), 1):
        names = ", ".join(f["name"] for f in turn.get("attachments", []))
        lines.append(f"Сообщение {i}: «{turn['text']}»" + (f" Вложения: {names}." if names else ""))
    if task.get("corpus"):
        lines.append(f"Материалы человека: «{task['corpus']['title']}» ({task['corpus']['placement']}).")
    for base in task.get("knowledge_bases", []):
        lines.append(f"База знаний «{base['name']}»: {len(base.get('files', []))} файлов.")
    if task.get("my_files"):
        lines.append(f"Файлы в хранилище: {len(task['my_files'])}.")
    if task.get("reply_if_asked"):
        lines.append(f"Если система спросит, человек ответит: «{task['reply_if_asked']}».")
    return "\n".join(lines)


DIALOG_QUESTION_CHARS = 2000


def _dialog(record: dict) -> str:
    """Вопросы системы и ответы человека в прогоне. Судья видит ответ системы на сообщение, а что человек сказал на её

    вопрос (например, что других сведений у него нет), без этого не знает, хотя от сказанного зависит, верно ли система

    поступила с недостающим. Вопрос показан концом: длинный ответ с вопросом кончается самим вопросом."""
    turns = record.get("turns") or []
    lines = []
    for previous, turn in zip(turns, turns[1:]):
        if not turn.get("reply"):
            continue
        question = (previous.get("answer") or "").strip()
        if len(question) > DIALOG_QUESTION_CHARS:
            question = "[… начало ответа опущено …] " + question[-DIALOG_QUESTION_CHARS:]
        lines.append(f"Система спросила: «{question}»\nЧеловек ответил: «{turn.get('text', '')}»")
    return "\n\n".join(lines)


def _delivery(output: Output) -> tuple[str, str]:
    """Текст выдачи для судьи и полный текст для сверки цитат. Имя выданного файла — тоже выдача: пункт «выдан документ Word»

    судья подкрепляет именем файла, и без имени в тексте сверки верный вердикт становился «нет». У задачи из нескольких

    сообщений судья видит ответ на каждое: пункты рубрики говорят о ходах («заметка создана», «найдена», «удалена»), и по

    одному последнему ответу их было не засчитать."""
    answers = output.messages()
    if len(answers) > 1:
        parts = [f"## Ответ системы на сообщение {n}\n{answer}" for n, answer in enumerate(answers, 1)]
        full = list(answers)
    else:
        parts = [f"## Ответ системы\n{output.answer}"]
        full = [output.answer]
    for f in output.files():
        text = output.file_text(f)
        heading = f"## Выданный файл «{f['name']}»"
        full.append(f"{heading}\n{text}")
        shown = text if len(text) <= MAX_FILE_CHARS else text[:MAX_FILE_CHARS] + "\n[… файл обрезан для судьи …]"
        parts.append(f"{heading}\n{shown}")
    joined = "\n\n".join(parts)
    if len(joined) > MAX_OUTPUT_CHARS:
        joined = joined[:MAX_OUTPUT_CHARS] + "\n[… выдача обрезана для судьи …]"
    return joined, "\n".join(full)


def _squash(text: str) -> str:
    return re.sub(r"[^0-9a-zа-я]+", "", text)


def _quote_found(quote: str, full: str) -> bool:
    """Цитата есть в тексте дословно. Пропуск, отмеченный многоточием, допустим: каждая часть между многоточиями должна

    найтись в тексте дословно, в любом порядке (судья перечисляет места в своём порядке). Части сверяются без знаков

    препинания и разметки: цитата могла пересечь границу ячеек или строк."""
    parts = [p for p in re.split(r"\s*(?:\[\s*(?:\.\.\.|…)\s*\]|\.\.\.|…)\s*", normalize(quote)) if len(_squash(p)) >= 4]
    if not parts:
        return False
    text = normalize(full)
    if len(parts) == 1 and parts[0].strip(" .") in text:
        return True
    squashed = _squash(text)
    return all(_squash(part) in squashed for part in parts) and sum(len(_squash(p)) for p in parts) >= 6


VERIFY_SYSTEM = """Ты сверяешь с источниками одно утверждение, которое проверяющий счёл выдумкой в выдаче системы. Тебе даны

утверждение (дословная цитата из выдачи) и место выдачи, где оно стоит (цитата в нём выделена знаками ⟦ ⟧), довод проверяющего, эталонный ответ и отрывки

материалов человека, найденные поиском по словам и числам утверждения; у задачи с подключённой системой (1С, Jira, GitHub)

среди отрывков и то, что система получила из неё своими умениями; среди отрывков и дата, когда человек написал, — «сегодня»

задачи, и календарь — день недели каждой даты, названной в утверждении и доводе: он посчитан кодом и верен.



Отрывки, дата и календарь — первоисточник. Эталон — мерило ответа, а не перечень всего верного: о многом верном он молчит.

Довод проверяющего — его мнение, и оно может ошибаться. Смысл утверждения бери из его места в выдаче: к чему относится

значение и что о нём сказано.



Реши:

* «supported» — утверждение прямо следует из отрывков материалов или из эталона: те же значения, и относятся они к тому

  же, о чём говорит утверждение в своём месте выдачи. Подтверждения отрывком достаточно, даже когда эталон о нём молчит.

  Приведи дословную цитату из отрывка или эталона (символ в символ), которая это подтверждает: место целиком, со словами

  вокруг значения, а не одно число.

* «fabrication» — подтверждения нет: утверждение противоречит отрывкам или эталону либо опирается на то, чего в них

  нет. Цитата пустая.

Совпадение отдельного числа или слова — ещё не подтверждение. Ответ — строго JSON по схеме."""

VERIFY_SCHEMA = {
    "type": "object",
    "properties": {
        "reasoning": {"type": "string"},
        "verdict": {"type": "string", "enum": ["supported", "fabrication"]},
        "quote": {"type": "string"},
    },
    "required": ["reasoning", "verdict", "quote"],
}

IDENTIFIER = re.compile(r"\b\d{1,2}\.\d{1,2}\.\d{4}\b|№\s?[\w\-/.]*\d[\w\-/.]*")

PASSAGE_CHARS = 900
PASSAGES = 8
STEM = 5

_INDEX: dict[str, list[tuple[str, str, set, set]]] = {}


def _stems(text: str) -> set:
    return {w[:STEM] for w in normalize(text).replace("-", " ").split() if len(w) >= STEM and w.isalpha()}


def _chunks(name: str, text: str) -> list[tuple[str, str, set, set]]:
    """Отрывки файла целыми строками: имя файла, текст, числа и основы слов."""
    out, current = [], []
    size = 0
    for line in text.splitlines():
        if size + len(line) > PASSAGE_CHARS and current:
            out.append("\n".join(current))
            current, size = [], 0
        current.append(line[:PASSAGE_CHARS * 2])
        size += len(line) + 1
    if current:
        out.append("\n".join(current))
    return [(name, chunk, set(numbers(chunk)), _stems(chunk)) for chunk in out if chunk.strip()]


def materials_index(task: dict, dataset: Path) -> list[tuple[str, str, set, set]]:
    """Отрывки всех материалов задачи: вложений, баз знаний, хранилища и корпуса."""
    files = [f for turn in task.get("turns", []) for f in turn.get("attachments", [])]
    files += [f for base in task.get("knowledge_bases", []) for f in base.get("files", [])]
    files += task.get("my_files", [])
    if task.get("corpus"):
        manifest = dataset / "corpora" / task["corpus"]["id"] / "manifest.json"
        files += json.loads(manifest.read_text(encoding="utf-8")).get("files", [])
    index = []
    for f in files:
        if f["path"] not in _INDEX:
            try:
                # У скана текста нет: судья читает его оригинал с текстовым слоем (originals/), системам он не дан.
                original = dataset / "originals" / f["path"]
                text = extract(original if original.exists() else dataset / f["path"])
            except Exception as error:  # noqa: BLE001 — нечитаемый файл не останавливает суд
                text = f"[файл не прочитан: {error}]"
            _INDEX[f["path"]] = _chunks(f["name"], text)
        index += _INDEX[f["path"]]
    return index


def system_outputs(record: dict) -> list[tuple[str, str, set, set]]:
    """Отрывки выдачи умений подключённой системы (1С, Jira, GitHub). Её данных в материалах задачи нет: без выдачи

    сверка считала выдумкой то, что система прочла в двойнике (2026-10-22: 8.01 и 8.05 — Д=0 при верном ответе). Выдачу

    прогон пишет только у задач с подключённой системой."""
    out = []
    for action in record.get("actions", []):
        if action.get("result"):
            out += _chunks(f"выдача подключённой системы: умение {action.get('name', '')}", action["result"])
    return out


def asked_at(record: dict) -> list[tuple[str, str, set, set]]:
    """Дата, когда человек написал, отрывком сверки: ответ «на сегодня» законно называет её, а в материалах задачи её нет

    (2026-10-22, 8.01: «остаток на 22.10.2026» засчитан выдумкой)."""
    today = started_on(record)
    if today is None:
        return []
    return _chunks("дата сообщения человека", f"Человек написал {today:%d.%m.%Y} ({record['started']}); это «сегодня» задачи.")


def started_on(record: dict) -> datetime.date | None:
    """День, когда человек написал: начало прогона."""
    match = re.match(r"(\d{4})-(\d{2})-(\d{2})", record.get("started") or "")
    try:
        return datetime.date(*map(int, match.groups())) if match else None
    except ValueError:
        return None


MONTHS = ["января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря"]
WEEKDAYS = ["понедельник", "вторник", "среда", "четверг", "пятница", "суббота", "воскресенье"]
# Записи даты: «21.10.2026», «2026-10-21», «21 октября 2026» и «21 октября» без года.
DATES = re.compile(
    r"(?<!\d)(?P<d1>\d{1,2})\.(?P<m1>\d{1,2})\.(?P<y1>\d{4})(?!\d)"
    r"|(?<!\d)(?P<y2>\d{4})-(?P<m2>\d{2})-(?P<d2>\d{2})(?!\d)"
    r"|(?<!\d)(?P<d3>\d{1,2})\s+(?P<m3>" + "|".join(MONTHS) + r")(?![а-яё])(?:\s+(?P<y3>\d{4})(?!\d))?",
    re.IGNORECASE)


def calendar(claim: str, year: int | None = None) -> list[tuple[str, str]]:
    """День недели каждой даты утверждения отрывком сверки. В материалах дня недели обычно нет, а судья — та же модель и

    путает его: 2026-10-31, 2.07 — верное «21 октября 2026 года — среда» записано выдумкой с доводом «это вторник», и снять

    его было нечем. Дата без года («21 октября») берёт год задачи (``year``); он назван в строке календаря, и сверка видит,

    к какому году отнесён день."""
    lines = []
    for match in DATES.finditer(claim):
        if match.group("d1"):
            day, month, found_year = match.group("d1"), match.group("m1"), match.group("y1")
        elif match.group("y2"):
            day, month, found_year = match.group("d2"), match.group("m2"), match.group("y2")
        else:
            day, month, found_year = match.group("d3"), MONTHS.index(match.group("m3").lower()) + 1, match.group("y3")
        if found_year is None and year is None:
            continue
        try:
            date = datetime.date(int(found_year) if found_year else year, int(month), int(day))
        except ValueError:
            continue
        line = f"{date:%d.%m.%Y} ({date.day} {MONTHS[date.month - 1]} {date.year} года) — {WEEKDAYS[date.weekday()]}"
        if line not in lines:
            lines.append(line)
    return [("календарь", "\n".join(lines))] if lines else []


def passages(claim: str, index: list[tuple[str, str, set, set]]) -> list[tuple[str, str]]:
    """Отрывки, где больше всего чисел и слов утверждения, с весом редкости (IDF); число весит втрое. Дата и номер документа

    («29.12.2025», «№ 532-ФЗ») сверяются целиком и весят больше всего: по отдельным числам дата теряется среди сотен

    поправок с тем же годом."""
    wanted_numbers, wanted_stems = set(numbers(claim)), _stems(claim)
    literals = {normalize(m.group(0)) for m in IDENTIFIER.finditer(claim)}
    total = len(index) or 1
    weight = {}
    for key, field in [(n, 2) for n in wanted_numbers] + [(w, 3) for w in wanted_stems]:
        frequency = sum(1 for entry in index if key in entry[field])
        weight[(field, key)] = math.log((total + 1) / (frequency + 0.5)) * (3 if field == 2 else 1)
    for literal in literals:
        frequency = sum(1 for entry in index if literal in normalize(entry[1]))
        weight[(0, literal)] = math.log((total + 1) / (frequency + 0.5)) * 6
    scored = []
    for name, chunk, chunk_numbers, chunk_stems in index:
        score = sum(weight[(2, n)] for n in wanted_numbers & chunk_numbers) + sum(weight[(3, w)] for w in wanted_stems & chunk_stems)
        if literals:
            text = normalize(chunk)
            score += sum(weight[(0, literal)] for literal in literals if literal in text)
        if score > 0:
            scored.append((score, name, chunk))
    scored.sort(key=lambda x: -x[0])
    return [(name, chunk) for _, name, chunk in scored[:PASSAGES]]


def _ask(base_url: str, model: str, api_key: str, system: str, user: str, schema: dict, max_tokens: int) -> tuple[dict, dict]:
    body = {
        "model": model,
        "messages": [{"role": "system", "content": system}, {"role": "user", "content": user}],
        "temperature": 0,
        "seed": 20261020,
        "max_tokens": max_tokens,
        "response_format": {"type": "json_schema", "json_schema": {"name": "verdict", "schema": schema, "strict": True}},
    }
    request = urllib.request.Request(f"{base_url.rstrip('/')}/chat/completions", data=json.dumps(body).encode("utf-8"),
                                     headers={"Content-Type": "application/json", "Authorization": f"Bearer {api_key}"})
    # Судья делит модель с прогонами: под нагрузкой сервер рвёт соединение или не отвечает в срок, и задача без вердикта
    # получала ноль по существу (2026-10-30: 7.01 и 7.02 — «RemoteDisconnected» и «timed out»). Сбой связи повторяется с
    # паузой; ответ при той же затравке и нулевой температуре тот же, так что повтор оценки не меняет. Оборванный ответ,
    # который кончился не пределом длины, — тот же сбой сервера (2026-10-31: 2.07 — вердикт из 14 знаков), и он тоже
    # повторяется; обрыв на пределе длины уходит вызывающему, который просит ответ короче.
    for attempt in range(JUDGE_ATTEMPTS):
        choice = {}
        try:
            with urllib.request.urlopen(request, timeout=900) as response:
                reply = json.loads(response.read().decode("utf-8"))
            choice = reply["choices"][0]
            return json.loads(choice["message"]["content"]), reply.get("usage", {})
        except json.JSONDecodeError:
            if choice.get("finish_reason") == "length" or attempt == JUDGE_ATTEMPTS - 1:
                raise
        except urllib.error.HTTPError as error:
            # Отказ сервера в самом запросе (400 — затравка длиннее окна, 401, 404) повтором не лечится; повторяются
            # перегрузка и сбой сервера (5xx), истёкший срок (408) и предел частоты (429).
            if (error.code < 500 and error.code not in (408, 429)) or attempt == JUDGE_ATTEMPTS - 1:
                raise
        except (urllib.error.URLError, http.client.HTTPException, ConnectionError, TimeoutError):
            if attempt == JUDGE_ATTEMPTS - 1:
                raise
        time.sleep(60 * (attempt + 1))


BRIEF = ("\n\nПиши кратко: рассуждение по пункту не длиннее двух предложений, цитата не длиннее 200 знаков, у галлюцинации "
         "довод в одно предложение. Прошлый ответ не уместился в предел длины.")


def _ask_verdict(base_url: str, model: str, api_key: str, user: str) -> tuple[dict, dict]:
    """Вердикт судьи; если ответ оборвался на пределе длины, судья отвечает ещё раз короче и с большим пределом."""
    try:
        return _ask(base_url, model, api_key, SYSTEM, user, SCHEMA, 12000)
    except json.JSONDecodeError:
        return _ask(base_url, model, api_key, SYSTEM + BRIEF, user, SCHEMA, 16000)


CONTEXT_CHARS = 300
CONTEXT_PLACES = 3


def claim_context(quote: str, delivery: str) -> str:
    """Место выдачи, где стоит утверждение: строки вокруг каждого вхождения начала цитаты, до трёх мест, с цитатой,

    выделенной знаками ⟦ ⟧. Без места короткая цитата теряет смысл — к чему относится значение, сверка не видит и сравнивает

    его не с тем (2026-11-01, onec-stock: сумма прихода «48 000» записана выдумкой доводом «это приход, а не остаток»); без

    выделения она читается соседним значением места (там же «18 000» расхода прочитано строкой остатка «18 единиц на сумму

    15 000»)."""
    head = re.split(r"\s*(?:\[\s*(?:\.\.\.|…)\s*\]|\.\.\.|…)\s*", quote.strip())[0].strip(" .")
    if len(head) < 2:
        return ""
    lowered, needle = delivery.lower(), head.lower()
    places: list[str] = []
    start = 0
    while len(places) < CONTEXT_PLACES:
        at = lowered.find(needle, start)
        if at < 0:
            break
        begin = max(delivery.rfind("\n", 0, max(0, at - CONTEXT_CHARS)) + 1, at - 2 * CONTEXT_CHARS)
        stop = delivery.find("\n", at + len(head) + CONTEXT_CHARS)
        end = min(len(delivery) if stop < 0 else stop, at + len(head) + 2 * CONTEXT_CHARS)
        place = (delivery[begin:at] + "⟦" + delivery[at:at + len(head)] + "⟧" + delivery[at + len(head):end]).strip()
        if place and place not in places:
            places.append(place)
        start = at + len(head)
    return "\n[…]\n".join(places)


VERIFY_BRIEF = "\n\nПиши кратко: рассуждение не длиннее трёх предложений. Прошлый ответ не уместился в предел длины."


def verify_fabrication(fabrication: dict, task: dict, index: list, base_url: str, model: str, api_key: str,

                       today: datetime.date | None = None, delivery: str = "") -> tuple[bool, dict, dict]:
    """Подтверждают ли материалы или эталон утверждение, которое судья счёл выдумкой: (снять, сверка, расход). Сверка,

    которая не дала ответа по форме и короче, выдумку не снимает: снимает только подтверждение."""
    claim = fabrication["quote"] + " " + fabrication.get("why", "")
    found = passages(claim, index) + calendar(claim, today.year if today else None)
    reference = task.get("reference_answer") or "(эталона нет)"
    user = (
        f"# Утверждение из выдачи\n{fabrication['quote']}\n\n"
        f"# Где оно стоит в выдаче\n{claim_context(fabrication['quote'], delivery) or '(место не найдено)'}\n\n"
        f"# Довод проверяющего\n{fabrication.get('why', '')}\n\n"
        f"# Эталонный ответ\n{reference}\n\n# Отрывки материалов человека и выдачи подключённой системы\n"
        + ("\n\n".join(f"## «{name}»\n{chunk}" for name, chunk in found) or "(по словам и числам утверждения ничего не нашлось)")
    )
    try:
        raw, usage = _ask(base_url, model, api_key, VERIFY_SYSTEM, user, VERIFY_SCHEMA, 2000)
    except json.JSONDecodeError:
        try:
            raw, usage = _ask(base_url, model, api_key, VERIFY_SYSTEM + VERIFY_BRIEF, user, VERIFY_SCHEMA, 4000)
        except json.JSONDecodeError:
            return False, {"verdict": None, "quote": "", "quote_verified": False,
                           "reasoning": "сверка не дала ответа по форме", "passages": [name for name, _ in found]}, {}
    quote = raw.get("quote", "")
    sources = reference + "\n" + "\n".join(chunk for _, chunk in found)
    confirmed = (raw.get("verdict") == "supported" and len(normalize(quote).strip(" .…")) >= 8 and _quote_found(quote, sources))
    return confirmed, {"verdict": raw.get("verdict"), "quote": quote, "quote_verified": confirmed,
                       "reasoning": raw.get("reasoning", ""), "passages": [name for name, _ in found]}, usage


def _add(total: dict, usage: dict) -> None:
    for key, value in usage.items():
        if isinstance(value, int):
            total[key] = total.get(key, 0) + value


def judge(task: dict, record: dict, root: Path, base_url: str, model: str, api_key: str = "none", dataset: Path | None = None) -> dict:
    output = Output(record, root)
    shown, full = _delivery(output)
    # Судья не знает, какой пункт критический: каждый он судит одинаково строго, а пометку учитывает отчёт.
    rubric = [text for text, _ in rubric_items(task)]
    must_not = task.get("must_not", [])
    dialog = _dialog(record)
    user = (
        f"# Просьба и материалы\n{_materials_summary(task)}\n\n"
        + (f"# Вопросы системы и ответы человека\n{dialog}\n\n" if dialog else "")
        + f"# Эталонный ответ\n{task.get('reference_answer', '(эталона нет — суди по рубрике и материалам)')}\n\n"
        "# Рубрика\n" + "\n".join(f"{i}. {item}" for i, item in enumerate(rubric, 1)) + "\n\n"
        "# Запрещённые утверждения\n" + ("\n".join(f"{i}. {item}" for i, item in enumerate(must_not, 1)) or "нет") + "\n\n"
        f"# Выдача системы\n{shown}"
    )
    raw, usage = _ask_verdict(base_url, model, api_key, user)
    total: dict = {}
    _add(total, usage)

    items = []
    for i, text in enumerate(rubric, 1):
        given = next((r for r in raw.get("rubric", []) if r.get("item") == i), None)
        verdict = given["verdict"] if given else "missing"
        quote = (given or {}).get("quote", "")
        verified = _quote_found(quote, full) if quote else False
        # Сказанное системой засчитывается только по цитате, найденной в выдаче: иначе судья мог бы и засчитать то, чего
        # нет, и приписать системе неверное. «yes» без цитаты допустим у пункта об отсутствии в выдаче.
        if (verdict in ("yes", "partial", "wrong") and quote and not verified) or (verdict in ("partial", "wrong") and not quote):
            verdict = "missing"
        items.append({"item": text, "verdict": verdict, "quote": quote, "quote_verified": verified,
                      "reasoning": (given or {}).get("reasoning", "")})
    quoted = [f for f in raw.get("fabrications", []) if _quote_found(f.get("quote", ""), full)]

    # Второй проход: выдумка, кроме запрещённого утверждения задачи, сверяется с материалами и снимается только по
    # дословному подтверждению.
    fabrications, refuted = [], []
    index = (materials_index(task, dataset) + system_outputs(record) + asked_at(record)
             if dataset is not None and any(not f.get("must_not") for f in quoted) else [])
    for f in quoted:
        if f.get("must_not") or dataset is None:
            fabrications.append(f)
            continue
        confirmed, check, usage = verify_fabrication(f, task, index, base_url, model, api_key, started_on(record), full)
        _add(total, usage)
        (refuted if confirmed else fabrications).append({**f, "verification": check})
    return {
        "rubric": items,
        "fabrications": fabrications,
        "refuted_fabrications": refuted,
        "discarded_fabrications": [f for f in raw.get("fabrications", []) if f not in quoted],
        "usage": total,
    }


def _env(*names: str) -> str | None:
    return next((os.environ[name] for name in names if os.environ.get(name)), None)


def model_url(url: str) -> str:
    """Адрес модели, достижимый отсюда: в контейнере localhost — сам контейнер, а модель слушает на машине, где он запущен.

    Docker Desktop знает её как host.docker.internal, на Linux имя даёт ключ ``--add-host host.docker.internal:host-gateway``."""
    if Path("/.dockerenv").exists():
        return re.sub(r"^(https?://)(localhost|127\.0\.0\.1|\[::1\])(?=[:/]|$)", r"\1host.docker.internal", url)
    return url


def add_connection_arguments(parser: argparse.ArgumentParser) -> None:
    """Ключи подключения к модели судьи с умолчаниями из окружения (см. начало файла)."""
    parser.add_argument("--base-url", default=_env("JUDGE_BASE_URL", "WORKPERMIT_MODEL_URL"),
                        help="адрес модели, совместимый с OpenAI; по умолчанию JUDGE_BASE_URL или WORKPERMIT_MODEL_URL")
    parser.add_argument("--model", default=_env("JUDGE_MODEL", "WORKPERMIT_MODEL"),
                        help="имя модели; по умолчанию JUDGE_MODEL или WORKPERMIT_MODEL")
    parser.add_argument("--api-key", default=_env("JUDGE_API_KEY", "WORKPERMIT_MODEL_KEY") or "none",
                        help="ключ модели; по умолчанию JUDGE_API_KEY или WORKPERMIT_MODEL_KEY")


def check_connection(parser: argparse.ArgumentParser, args: argparse.Namespace) -> None:
    if not args.base_url or not args.model:
        parser.error("модель судьи не задана: --base-url и --model или переменные WORKPERMIT_MODEL_URL и WORKPERMIT_MODEL")
    args.base_url = model_url(args.base_url)


def main(argv: list[str]) -> int:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("tasks")
    parser.add_argument("run")
    add_connection_arguments(parser)
    parser.add_argument("--only", nargs="*", help="имена задач")
    args = parser.parse_args(argv[1:])
    check_connection(parser, args)

    tasks = {json.loads(line)["id"]: json.loads(line) for line in Path(args.tasks).read_text(encoding="utf-8").splitlines() if line.strip()}
    dataset = Path(args.tasks).resolve().parent.parent
    failed = []
    for task_dir in sorted(p for p in Path(args.run).iterdir() if p.is_dir()):
        if args.only is not None and task_dir.name not in args.only:
            continue
        record_path = task_dir / "record.json"
        if not record_path.exists() or task_dir.name not in tasks:
            continue
        record = json.loads(record_path.read_text(encoding="utf-8"))
        # Задачу система не запускала: судить нечего.
        if record.get("status") == "not_run":
            continue
        # Сбой судьи на одной задаче не останавливает остальные; задача без вердикта называется в конце и в отчёте.
        try:
            verdict = judge(tasks[task_dir.name], record, task_dir, args.base_url, args.model, args.api_key, dataset)
        except Exception as error:  # noqa: BLE001
            failed.append(task_dir.name)
            print(f"{task_dir.name}: СУДЬЯ НЕ ДАЛ ВЕРДИКТА: {type(error).__name__}: {str(error)[:200]}")
            continue
        (task_dir / "judge.json").write_text(json.dumps(verdict, ensure_ascii=False, indent=1), encoding="utf-8")
        verdicts = [r["verdict"] for r in verdict["rubric"]]
        print(f"{task_dir.name}: верно {verdicts.count('yes')}/{len(verdicts)}, неверно {verdicts.count('wrong')},"
              f" галлюцинаций {len(verdict['fabrications'])} (снято сверкой {len(verdict['refuted_fabrications'])})")
    if failed:
        print("без вердикта судьи:", ", ".join(failed))
    return 1 if failed else 0


if __name__ == "__main__":
    sys.exit(main(sys.argv))