Оценка прогона одной командой (eval/evaluate.py), модель из переменных WORKPERMIT_MODEL_*, прогон по частям в одном run.json, ключ «none» для агента без ключа, округление Q как на сайте

README.md

@@ -86,7 +86,7 @@ tasks/<задача>/turn-N/    вложения N-го сообщения
 tasks/<задача>/knowledge/ базы знаний задачи
 tasks/<задача>/my-files/  файлы хранилища человека
 originals/<путь>          оригинал каждого скана с текстовым слоем: только для судьи при сверке выдумок, системам не даётся
-eval/                     проверки, судья, меры, отчёт, извлечение текста, контейнер оценки
+eval/                     проверки, судья, меры, отчёт, извлечение текста, оценка прогона одной командой, контейнер оценки
 runners/dsh/              прогон агента DeepSeek Harness: образ агента, шлюз к модели, серверы MCP (двойники 1С, Jira,
                           GitHub, память, органайзер), прогонщик, проверка связки без модели
 ```
@@ -109,7 +109,8 @@ runners/dsh/              прогон агента DeepSeek Harness: образ
 - **Судья** (`eval/judge.py`): та же модель, что у систем (Qwen3.8-27B), температура 0, ответ по JSON-схеме, система ему
   неизвестна. Судья судит каждую задачу, и с проверками кода тоже: полноту и галлюцинации оценивает только он. Каждый
   пункт рубрики он сверяет с эталоном и отмечает «верно», «частично», «неверно» или «нет в ответе» с дословной цитатой из
-  выдачи, код ищет её в выдаче. Галлюцинации и искажения (противоречия эталону или материалам и факты, взятые ниоткуда)
+  выдачи, код ищет её в выдаче: вердикт с цитатой, которой в выдаче нет, как и «частично» или «неверно» без цитаты,
+  становится «нет в ответе» («верно» без цитаты судья ставит только пункту о том, чего в выдаче быть не должно). Галлюцинации и искажения (противоречия эталону или материалам и факты, взятые ниоткуда)
   он подкрепляет цитатой; каждая сверяется с отрывками материалов (сканы по их оригиналам из `originals/`) и снимается
   только по дословному подтверждению, которое находит код.
 - **Меры** (`eval/report.py`), «верно» 1, «частично» 0,5:
@@ -131,15 +132,19 @@ runners/dsh/              прогон агента DeepSeek Harness: образ
 формул пересчитывается LibreOffice, как её увидел бы человек.
 
 Как оценить свою систему: прогнать задачи, записать ответы в формате `record.json` в папки
-`<прогон>/<система>/<задача>/`, затем:
+`runs/<прогон>/<система>/<задача>/`, задать модель судьи переменными окружения (судья — та же модель, что у систем; модель
+на этой же машине указывается как `localhost`) и оценить весь прогон одной командой `eval/evaluate.py`: проверки кода и
+судья по каждой системе, затем отчёт `runs/<прогон>/report.md` и `report.json`:
 
 ```bash
+export WORKPERMIT_MODEL_URL=http://localhost:8000/v1 WORKPERMIT_MODEL=<модель> WORKPERMIT_MODEL_KEY=<ключ>
 docker build -t workpermit-eval eval
-docker run --rm -v $PWD:/dataset -v $PWD/runs:/runs workpermit-eval checks.py /dataset/data/tasks.jsonl /runs/<прогон>/<система>
-docker run --rm -v $PWD:/dataset -v $PWD/runs:/runs workpermit-eval judge.py /dataset/data/tasks.jsonl /runs/<прогон>/<система> --base-url http://host:8000/v1 --model <модель> --api-key <ключ>
-docker run --rm -v $PWD:/dataset -v $PWD/runs:/runs workpermit-eval report.py /dataset/data/tasks.jsonl /runs/<прогон>
+docker run --rm -v $PWD:/dataset -v $PWD/runs:/runs -e WORKPERMIT_MODEL_URL -e WORKPERMIT_MODEL -e WORKPERMIT_MODEL_KEY workpermit-eval evaluate.py /dataset/data/tasks.jsonl /runs/<прогон>
 ```
 
+На Linux контейнеру нужен ещё ключ `--add-host host.docker.internal:host-gateway`, если модель на этой же машине. Шаги
+по отдельности: `checks.py` и `judge.py` по папке системы, `report.py` по папке прогона.
+
 ## Условия сравнения
 
 Бенчмарк составила команда Santify, одной из сравниваемых систем; поэтому задачи, эталоны, проверки и код оценки открыты
@@ -151,8 +156,7 @@ Word, Excel, PowerPoint, PDF, poppler для страниц PDF). Обе сис
 во внутренней сети Docker, где видна только модель. Агенту материалы кладутся в рабочую папку по тем же местам, к словам
 человека добавляется одна строка о том, где они лежат. Подключённую систему, память и органайзер агент получает от серверов
 MCP прогонщика (плагин `dsh-mcp-client`): подключённые системы отвечают теми же двойниками, что у Santify, а органайзер
-снимается в запись в том же виде. В первом прогоне (2026-10-21) серверов ещё не было, и восемнадцать задач с ними у агента
-не запускались. Сервер модели принимает одно изображение за запрос, поэтому шлюз
+снимается в запись в том же виде. Сервер модели принимает одно изображение за запрос, поэтому шлюз
 оставляет в запросе агента последнее изображение, а прежние заменяет пометкой «прочитайте файл ещё раз», как сделал бы
 собственный модуль выгрузки изображений агента. Сжатие истории агента настроено под окно 64 000 (запас 4 096 токенов,
 порог 80 % окна): по умолчанию оно рассчитано на большие окна и при таком окне не срабатывает. Рассуждение модели
@@ -160,21 +164,23 @@ MCP прогонщика (плагин `dsh-mcp-client`): подключённы
 
 ## Как повторить прогон агента DeepSeek Harness
 
-Прогонщик (`runners/dsh/run.py`, Python 3.10+ без сторонних пакетов) ведёт задачу по тем же правилам, что прогон первого
-сравнения: та же раскладка материалов и строка о папках, разговоры сессиями агента, тот же ответ человека на вопрос, та же
-запись `record.json`. Серверы MCP с подключёнными системами, памятью и органайзером добавлены после первого прогона
-(2026-10-21). Агент работает в контейнере во внутренней сети Docker: модель он видит через шлюз, а серверы MCP работают
-рядом, в той же сети. Santify здесь не повторить: у неё нет открытого API.
+Прогонщик (`runners/dsh/run.py`, Python 3.10+ без сторонних пакетов) ведёт задачу по правилам раздела «Условия
+сравнения»: раскладка материалов по местам и строка о папках, разговоры сессиями агента, ответ человека на вопрос, запись
+`record.json`. Агент работает в контейнере во внутренней сети Docker: модель он видит через шлюз, а серверы MCP с
+подключёнными системами, памятью и органайзером работают рядом, в той же сети. Santify здесь не повторить: у неё нет
+открытого API. Модель берётся из тех же переменных, что у судьи:
 
 ```bash
 docker build -t workpermit-dsh:0.2.0-rc.2 runners/dsh
 python runners/dsh/smoke.py . runs
-WORKPERMIT_MODEL_KEY=<ключ> python runners/dsh/run.py . runs --base-url http://host:8000/v1 --model <модель> --name <прогон>
+python runners/dsh/run.py . runs --name <прогон>
 ```
 
 `smoke.py` проверяет связку без модели: заглушка вместо модели вызывает инструмент MCP и отвечает. Модели нужны вызов
-инструментов и ввод изображений; первое сравнение шло на Qwen3.8-27B (vLLM) с окном 64 000 токенов и пределом ответа 8 192
-(`--context`, `--max-tokens`). Записи ложатся в `runs/<прогон>/dsh/<задача>/` и оцениваются командами раздела «Оценка».
+инструментов и ввод изображений; сравнение идёт на Qwen3.8-27B (vLLM) с окном 64 000 токенов и пределом ответа 8 192
+(`--context`, `--max-tokens`, это умолчания прогонщика). Имя прогона по умолчанию — сегодняшняя дата; прогон, который идёт
+несколько дней, продолжается тем же `--name`. Записи ложатся в `runs/<прогон>/dsh/<задача>/` и оцениваются командой
+раздела «Оценка».
 Требования, ключи прогонщика, устройство контейнеров и серверов MCP, особенности Linux и Windows описаны в
 [runners/dsh/README.md](runners/dsh/README.md).
 
@@ -395,7 +401,8 @@ A task counts as solved when no critical code check fails, every critical rubric
 hallucinations and both accuracy and completeness are at least 0.8. A task a system did not run because a
 required capability (connected system, memory, organiser) was not connected to it is left out of that system's totals, and
 systems are compared on the tasks all of them ran. The evaluation code ships in `eval/` with a Docker image
-(Python + LibreOffice) so that anyone can re-score the runs, and `runners/dsh/` reproduces the DeepSeek Harness run: the
+(Python + LibreOffice) so that anyone can re-score the runs (`eval/evaluate.py` scores a whole run in one command; the
+judge model is taken from `WORKPERMIT_MODEL_URL`, `WORKPERMIT_MODEL` and `WORKPERMIT_MODEL_KEY`), and `runners/dsh/` reproduces the DeepSeek Harness run: the
 agent image, the model gateway, MCP servers with the 1C, Jira and GitHub twins, memory and organiser, the runner and a
 model-free smoke test. Santify itself has no public API, so its run cannot be reproduced from the dataset.
 

eval/evaluate.py

@@ -0,0 +1,102 @@
+"""Оценка прогона одной командой: проверки кода и судья по каждой системе в папке прогона, затем отчёт.
+
+    python evaluate.py <tasks.jsonl> <папка прогона> [--systems santify,dsh] [--only <задача> …] [--rejudge]
+                       [--base-url …] [--model …] [--api-key …]
+
+Модель судьи без ключей берётся из окружения, как у judge.py: WORKPERMIT_MODEL_URL, WORKPERMIT_MODEL,
+WORKPERMIT_MODEL_KEY (общие с прогонщиком DeepSeek Harness) или свои у судьи JUDGE_BASE_URL, JUDGE_MODEL, JUDGE_API_KEY.
+
+- Проверки кода идут по всем задачам с записью: они без модели и быстрые, а запись могла смениться после прогона заново.
+- Судья судит задачи без вердикта и задачи с вердиктом прежней методики; ``--rejudge`` пересуживает все выбранные.
+- Отчёт (report.json и report.md) считается по всей папке прогона последним. Если у какой-то задачи остался вердикт
+  прежней методики (например, выбраны не все задачи через ``--only``), отчёт не считается и задачи называются.
+
+В контейнере оценки, где есть LibreOffice для книг Excel без посчитанных значений:
+
+    docker run --rm -v $PWD/dataset:/dataset -v $PWD/runs:/runs -e WORKPERMIT_MODEL_URL -e WORKPERMIT_MODEL \\
+        -e WORKPERMIT_MODEL_KEY workpermit-eval evaluate.py /dataset/data/tasks.jsonl /runs/<прогон>
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent))
+import checks  # noqa: E402
+import judge  # noqa: E402
+import report  # noqa: E402
+
+
+def to_judge(system_dir: Path, tasks: set[str], only: list[str] | None, rejudge: bool) -> list[str]:
+    """Задачи системы, которые судья должен судить: с записью, запущенные, выбранные, без вердикта нынешней методики
+    (или все при ``rejudge``)."""
+    chosen = []
+    for task_dir in sorted(p for p in system_dir.iterdir() if p.is_dir()):
+        record = task_dir / "record.json"
+        if task_dir.name not in tasks or not record.exists() or (only is not None and task_dir.name not in only):
+            continue
+        if json.loads(record.read_text(encoding="utf-8")).get("status") == "not_run":
+            continue
+        verdict = task_dir / "judge.json"
+        if rejudge or not verdict.exists() or report.judge_outdated(json.loads(verdict.read_text(encoding="utf-8"))):
+            chosen.append(task_dir.name)
+    return chosen
+
+
+def outdated(run: Path, systems: list[str], tasks: set[str]) -> list[str]:
+    """Задачи прогона, у которых вердикт судьи прежней методики: по ним отчёт не считается."""
+    found = []
+    for system in systems:
+        for verdict in sorted((run / system).glob("*/judge.json")):
+            if verdict.parent.name in tasks and report.judge_outdated(json.loads(verdict.read_text(encoding="utf-8"))):
+                found.append(f"{system}/{verdict.parent.name}")
+    return found
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("tasks")
+    parser.add_argument("run")
+    parser.add_argument("--systems", help="системы через запятую; по умолчанию все папки прогона")
+    parser.add_argument("--only", nargs="+", help="имена задач для судьи; проверки кода идут по всем")
+    parser.add_argument("--rejudge", action="store_true", help="пересудить и задачи с вердиктом нынешней методики")
+    judge.add_connection_arguments(parser)
+    args = parser.parse_args(argv[1:])
+
+    run = Path(args.run)
+    tasks = {json.loads(line)["id"] for line in Path(args.tasks).read_text(encoding="utf-8").splitlines() if line.strip()}
+    systems = args.systems.split(",") if args.systems else sorted(p.name for p in run.iterdir() if p.is_dir())
+    missing = [s for s in systems if not (run / s).is_dir()]
+    if missing:
+        parser.error(f"в папке прогона нет систем: {', '.join(missing)}")
+    plan = {system: to_judge(run / system, tasks, args.only, args.rejudge) for system in systems}
+    if any(plan.values()):
+        judge.check_connection(parser, args)
+
+    failed = False
+    for system in systems:
+        print(f"== {system}: проверки кода")
+        checks.main(["checks.py", args.tasks, str(run / system)])
+        if plan[system]:
+            print(f"== {system}: судья, задач {len(plan[system])}")
+            connection = ["--base-url", args.base_url, "--model", args.model, "--api-key", args.api_key]
+            failed |= judge.main(["judge.py", args.tasks, str(run / system), *connection, "--only", *plan[system]]) != 0
+        else:
+            print(f"== {system}: судить нечего, у всех задач вердикт нынешней методики")
+
+    # Отчёт идёт по всем системам папки прогона, и выбранным, и прочим: вердикт прежней методики у любой его остановил бы.
+    left = outdated(run, sorted(p.name for p in run.iterdir() if p.is_dir()), tasks)
+    if left:
+        print(f"отчёт не посчитан: у задач ({len(left)}) вердикт прежней методики: {', '.join(left[:10])}"
+              f"{', …' if len(left) > 10 else ''}; запустите evaluate.py по ним или без --only")
+        return 1
+    print("== отчёт")
+    report.main(["report.py", args.tasks, str(run)])
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

eval/judge.py

@@ -19,9 +19,12 @@
 Модель — та же, что у сравниваемых систем (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 <задача> …]
+    python judge.py <tasks.jsonl> <папка прогона системы> [--base-url http://host:8000/v1] [--model qwen3.8-27b] [--only <задача> …]
 
-Результат пишется в ``<задача>/judge.json`` рядом с ``record.json``.
+Подключение к модели без ключей берётся из окружения: 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
@@ -519,28 +522,55 @@ def judge(task: dict, record: dict, root: Path, base_url: str, model: str, api_k
     }
 
 
+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")
-    parser.add_argument("--base-url", required=True)
-    parser.add_argument("--model", required=True)
-    parser.add_argument("--api-key", default=os.environ.get("JUDGE_API_KEY", "none"), help="по умолчанию из JUDGE_API_KEY")
+    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 and task_dir.name not in args.only:
+        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"))
-        # Задачу система не запускала: судить нечего. «no_capability» — прежнее имя того же статуса в записях до 2026-11-08.
-        if record.get("status") in ("not_run", "no_capability"):
+        # Задачу система не запускала: судить нечего.
+        if record.get("status") == "not_run":
             continue
         # Сбой судьи на одной задаче не останавливает остальные; задача без вердикта называется в конце и в отчёте.
         try:

eval/report.py

@@ -40,6 +40,7 @@ import json
 import math
 import statistics
 import sys
+from decimal import ROUND_HALF_UP, Decimal
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent))
@@ -53,20 +54,29 @@ CAPABILITY_TITLES = {
     "onec": "1С", "jira": "Jira", "github": "GitHub", "safety": "безопасность",
 }
 
-# Задача, которую система не запускала. «no_capability» — прежнее имя того же статуса в записях до 2026-11-08.
-NOT_RUN = ("not_run", "no_capability")
+def tenths(value: float) -> float:
+    """Округление до десятых по школьному правилу (50,25 → 50,3), как округляет сайт: встроенное round и формат :.1f
+    округляют половину к чётному, и средний Q отчёта расходился с сайтом на десятую."""
+    return float(Decimal(str(value)).quantize(Decimal("0.1"), rounding=ROUND_HALF_UP))
+
 
 # Вердикты судьи по пункту рубрики (eval/judge.py, SCHEMA).
 VERDICTS = ("yes", "partial", "wrong", "missing")
 
 
+def judge_outdated(judge: dict) -> bool:
+    """Вердикт судьи прежней методики («no» вместо «wrong» и «missing», поле формы): меры его не различают, задачу нужно
+    пересудить judge.py. evaluate.py пересуживает такие задачи сам."""
+    return "form" in judge or any(r.get("verdict") not in VERDICTS for r in judge.get("rubric", []))
+
+
 def score_task(task: dict, task_dir: Path) -> dict:
     record = json.loads((task_dir / "record.json").read_text(encoding="utf-8"))
     base = {"task": task["id"], "category": task["category"], "requires": task["requires"], "platform_only": task["platform_only"],
             "status": record.get("status"), "seconds": record.get("seconds"), "model_calls": record.get("model_calls"),
             "tokens": (record.get("prompt_tokens") or 0) + (record.get("completion_tokens") or 0),
             "asked_unprompted": not task.get("reply_if_asked") and any(t.get("reply") for t in record.get("turns") or [])}
-    if record.get("status") in NOT_RUN:
+    if record.get("status") == "not_run":
         return {**base, "not_run": True, "reason": record.get("error")}
 
     checks = json.loads((task_dir / "checks.json").read_text(encoding="utf-8")) if (task_dir / "checks.json").exists() else []
@@ -75,11 +85,9 @@ def score_task(task: dict, task_dir: Path) -> dict:
     # Доля пройденных проверок кода; None — проверок кода у задачи нет.
     code = summary["accuracy"]
     if judge:
+        if judge_outdated(judge):
+            raise ValueError(f"{task_dir}: вердикт судьи прежней методики, пересудите задачу: evaluate.py или judge.py")
         verdicts = [r["verdict"] for r in judge["rubric"]]
-        # Вердикт прежней схемы судьи («no» вместо «wrong» и «missing») меры не различают: задачу нужно пересудить judge.py.
-        unknown = sorted(set(verdicts) - set(VERDICTS))
-        if unknown:
-            raise ValueError(f"{task_dir}: вердикты судьи {unknown} не из {list(VERDICTS)}, пересудите задачу judge.py")
         credit = verdicts.count("yes") + 0.5 * verdicts.count("partial")
         said = verdicts.count("yes") + verdicts.count("partial") + verdicts.count("wrong")
         judged = credit / said if said else 0.0
@@ -97,7 +105,7 @@ def score_task(task: dict, task_dir: Path) -> dict:
     rubric_failed = [text for text, critical in rubric_items(task) if critical and by_item.get(text) != "yes"]
     success = (not summary["critical_failed"] and not rubric_failed and G == 1.0 and T >= 0.8 and P >= 0.8
                and record.get("status") in ("completed", "asked", "deadline"))
-    return {**base, "Q": round(Q, 1), "success": success, "T": T, "T_judge": judged, "T_code": code, "P": P, "G": G,
+    return {**base, "Q": tenths(Q), "success": success, "T": T, "T_judge": judged, "T_code": code, "P": P, "G": G,
             "hallucinations": len(judge["fabrications"]) if judge else None, "forbidden": forbidden if judge else None,
             "critical_failed": summary["critical_failed"], "critical_rubric_failed": rubric_failed,
             "not_run": False, "judge_missing": judge is None}
@@ -199,8 +207,8 @@ def main(argv: list[str]) -> int:
     lines.append("|---|---|---|---|---|---|---|---|---|---|---|")
     for s in systems:
         a, sh = report["systems"][s]["all"], report["systems"][s]["shared"]
-        lines.append(f"| {s} | {a['solved']} из {a['tasks']} ({a['solved_share']:.0%}) | {a['ci95'][0]:.0%}–{a['ci95'][1]:.0%} | {a['Q']:.1f} ± {a['Q_ci95']:.1f} "
-                     f"| {sh['solved']} из {sh['tasks']} | {sh['Q']:.1f} | {'—' if a['hallucination_free_share'] is None else format(a['hallucination_free_share'], '.0%')} "
+        lines.append(f"| {s} | {a['solved']} из {a['tasks']} ({a['solved_share']:.0%}) | {a['ci95'][0]:.0%}–{a['ci95'][1]:.0%} | {tenths(a['Q'])} ± {tenths(a['Q_ci95'])} "
+                     f"| {sh['solved']} из {sh['tasks']} | {tenths(sh['Q'])} | {'—' if a['hallucination_free_share'] is None else format(a['hallucination_free_share'], '.0%')} "
                      f"| {a['hallucinations']} / {a['forbidden']} | {len(report['systems'][s]['not_run'])} | {len(a['asked_unprompted'])} | {a['seconds_median'] or '—'} |")
     lines += ["", f"Общих задач, которые решали все системы: {len(shared_ids)}."
               + (f" Различие систем на них (точный критерий Фишера): p = {report['fisher']['shared']:.3f}."

eval/test_eval.py

@@ -20,6 +20,7 @@ from unittest import mock
 
 sys.path.insert(0, str(Path(__file__).parent))
 import checks  # noqa: E402
+import evaluate  # noqa: E402
 import judge  # noqa: E402
 import report  # noqa: E402
 
@@ -306,6 +307,40 @@ class Measures(unittest.TestCase):
         with self.assertRaises(ValueError):
             self._score(["yes", "no", "yes", "yes"])
 
+    def test_half_of_a_tenth_rounds_up_like_the_site(self):
+        self.assertEqual((50.3, 59.3, 50.2), (report.tenths(50.25), report.tenths(59.25), report.tenths(50.2499)))
+
+    def test_previous_judge_schema_is_recognised_by_verdicts_or_form(self):
+        self.assertTrue(report.judge_outdated({"rubric": [{"verdict": "no"}], "fabrications": []}))
+        self.assertTrue(report.judge_outdated({"rubric": [{"verdict": "yes"}], "fabrications": [], "form": 4}))
+        self.assertFalse(report.judge_outdated({"rubric": [{"verdict": "wrong"}, {"verdict": "missing"}], "fabrications": []}))
+
+
+class Connection(unittest.TestCase):
+    """Модель судьи без ключей берётся из окружения: своя у судьи, иначе общая с прогонщиком DeepSeek Harness."""
+
+    def _parse(self, env: dict, argv: list[str] | None = None):
+        parser = judge.argparse.ArgumentParser()
+        with mock.patch.dict(judge.os.environ, env, clear=True):
+            judge.add_connection_arguments(parser)
+            return parser.parse_args(argv or [])
+
+    def test_shared_model_variables_are_the_default(self):
+        args = self._parse({"WORKPERMIT_MODEL_URL": "http://m:8000/v1", "WORKPERMIT_MODEL": "qwen", "WORKPERMIT_MODEL_KEY": "k"})
+        self.assertEqual(("http://m:8000/v1", "qwen", "k"), (args.base_url, args.model, args.api_key))
+
+    def test_judge_variables_and_arguments_win(self):
+        args = self._parse({"WORKPERMIT_MODEL_URL": "http://m/v1", "JUDGE_BASE_URL": "http://j/v1", "WORKPERMIT_MODEL": "qwen"},
+                           ["--model", "other"])
+        self.assertEqual(("http://j/v1", "other", "none"), (args.base_url, args.model, args.api_key))
+
+    def test_localhost_in_the_container_is_the_host_machine(self):
+        with mock.patch.object(judge.Path, "exists", return_value=True):
+            self.assertEqual("http://host.docker.internal:8000/v1", judge.model_url("http://localhost:8000/v1"))
+            self.assertEqual("http://10.0.0.5:8000/v1", judge.model_url("http://10.0.0.5:8000/v1"))
+        with mock.patch.object(judge.Path, "exists", return_value=False):
+            self.assertEqual("http://localhost:8000/v1", judge.model_url("http://localhost:8000/v1"))
+
 
 class Quotes(unittest.TestCase):
     TASK = {"rubric": ["Сумма 598 000 ₽ с монтажом", "Выдан документ Word"]}
@@ -399,11 +434,58 @@ class NotRun(unittest.TestCase):
         self.assertEqual(["общая"], result["shared_tasks"])
         self.assertEqual(1, result["systems"]["santify"]["shared"]["tasks"])
 
-    def test_record_before_the_rename_is_not_run_too(self):
+
+class Evaluate(unittest.TestCase):
+    """Прогон одной командой: судья судит задачи без вердикта и с вердиктом прежней методики, отчёт считается последним."""
+
+    TASKS = [{"id": id_, "category": 1, "category_title": "Сверка", "requires": [], "platform_only": False, "rubric": ["Итог назван"]}
+             for id_ in ("без-вердикта", "прежний", "нынешний", "не-запускалась")]
+    NEW = {"rubric": [{"item": "Итог назван", "verdict": "yes"}], "fabrications": []}
+    OLD = {"rubric": [{"item": "Итог назван", "verdict": "no"}], "fabrications": [], "form": 3}
+
+    def _run(self, root: Path) -> Path:
+        (root / "tasks.jsonl").write_text("\n".join(json.dumps(t, ensure_ascii=False) for t in self.TASKS), encoding="utf-8")
+        for task_id, status, verdict in (("без-вердикта", "completed", None), ("прежний", "completed", self.OLD),
+                                         ("нынешний", "completed", self.NEW), ("не-запускалась", "not_run", None)):
+            folder = root / "run" / "dsh" / task_id
+            folder.mkdir(parents=True)
+            (folder / "record.json").write_text(json.dumps({"status": status, "answer": "Итог 100"}), encoding="utf-8")
+            if verdict:
+                (folder / "judge.json").write_text(json.dumps(verdict), encoding="utf-8")
+        return root / "run"
+
+    def test_judges_tasks_without_a_current_verdict(self):
+        with tempfile.TemporaryDirectory() as folder:
+            run = self._run(Path(folder))
+            tasks = {t["id"] for t in self.TASKS}
+            self.assertEqual(["без-вердикта", "прежний"], evaluate.to_judge(run / "dsh", tasks, None, False))
+            self.assertEqual(["без-вердикта", "нынешний", "прежний"], evaluate.to_judge(run / "dsh", tasks, None, True))
+            self.assertEqual(["прежний"], evaluate.to_judge(run / "dsh", tasks, ["прежний", "нынешний"], False))
+
+    def test_whole_run_is_checked_judged_and_reported(self):
+        with tempfile.TemporaryDirectory() as folder:
+            run = self._run(Path(folder))
+            argv = ["evaluate.py", str(Path(folder) / "tasks.jsonl"), str(run), "--base-url", "http://m/v1", "--model", "qwen"]
+            with mock.patch.object(judge, "judge", return_value={**self.NEW, "refuted_fabrications": []}) as judged, \
+                    mock.patch("sys.stdout", io.StringIO()):
+                code = evaluate.main(argv)
+            result = json.loads((run / "report.json").read_text(encoding="utf-8"))
+        self.assertEqual(0, code)
+        self.assertEqual(2, judged.call_count)
+        self.assertEqual(3, result["systems"]["dsh"]["all"]["solved"])
+        self.assertEqual([{"task": "не-запускалась", "reason": None}], result["systems"]["dsh"]["not_run"])
+
+    def test_report_waits_for_tasks_left_with_the_previous_verdict(self):
         with tempfile.TemporaryDirectory() as folder:
-            (Path(folder) / "record.json").write_text(json.dumps({"status": "no_capability"}), encoding="utf-8")
-            scored = report.score_task({"id": "t", "category": 8, "requires": ["onec"], "platform_only": True}, Path(folder))
-        self.assertTrue(scored["not_run"])
+            run = self._run(Path(folder))
+            argv = ["evaluate.py", str(Path(folder) / "tasks.jsonl"), str(run), "--only", "без-вердикта",
+                    "--base-url", "http://m/v1", "--model", "qwen"]
+            with mock.patch.object(judge, "judge", return_value={**self.NEW, "refuted_fabrications": []}), \
+                    mock.patch("sys.stdout", io.StringIO()) as out:
+                code = evaluate.main(argv)
+            self.assertFalse((run / "report.json").exists())
+        self.assertEqual(1, code)
+        self.assertIn("dsh/прежний", out.getvalue())
 
 
 class Numbers(unittest.TestCase):

runners/dsh/README.md

@@ -4,9 +4,6 @@
 серверы MCP с двойниками подключённых систем, памятью и органайзером, прогонщик и проверка связки без модели. Нужен только
 датасет: кода сравниваемых систем не нужно. Прогон Santify отсюда не повторить: у неё нет открытого API.
 
-Прогонщик ведёт задачу по тем же правилам, что прогон первого сравнения (2026-10-21). Серверы MCP добавлены после него: в
-том прогоне восемнадцать задач с подключёнными системами, памятью и органайзером у агента не запускались.
-
 ## Что нужно
 
 - Docker: Docker Desktop (Windows, macOS) или Docker Engine 20.10+ (Linux).
@@ -15,7 +12,7 @@
 - Модель на адресе, совместимом с OpenAI (`/v1/chat/completions`), с вызовом инструментов (tool calling) и вводом
   изображений. У vLLM вызов инструментов включается ключом `--enable-auto-tool-choice` с парсером вызовов своей модели
   (`--tool-call-parser`). Сервер вправе принимать одно изображение за запрос: шлюз оставляет в запросе одно, последнее.
-  Первое сравнение шло на Qwen3.8-27B (vLLM) с окном 64 000 токенов и пределом ответа 8 192.
+  Сравнение идёт на Qwen3.8-27B (vLLM) с окном 64 000 токенов и пределом ответа 8 192.
 
 ## Запуск
 
@@ -34,17 +31,22 @@
    python runners/dsh/smoke.py . runs
    ```
 
-3. Прогон. Ключ модели — переменная `WORKPERMIT_MODEL_KEY` (агенту она приходит переменной окружения и нигде не
-   записывается); без ключа агент обращается к модели без него.
+3. Прогон. Модель задаётся один раз переменными окружения, общими с судьёй (`eval/judge.py`, `eval/evaluate.py`);
+   ключ агенту приходит переменной окружения и нигде не записывается; без ключа агент получает ключ «none», который
+   принимает сервер модели без ключа (пустой ключ агент не принимает и к модели не обращается).
+
+   ```bash
+   export WORKPERMIT_MODEL_URL=http://localhost:8000/v1 WORKPERMIT_MODEL=<модель> WORKPERMIT_MODEL_KEY=<ключ>
+   ```
 
    ```bash
-   WORKPERMIT_MODEL_KEY=<ключ> python runners/dsh/run.py . runs --base-url http://host:8000/v1 --model <модель> --name <прогон>
+   python runners/dsh/run.py . runs --name <прогон>
    ```
 
    | Ключ | Что задаёт | По умолчанию |
    |---|---|---|
-   | `--base-url` | адрес модели; `localhost` шлюз видит как `host.docker.internal` | обязателен |
-   | `--model` | имя модели на сервере | обязателен |
+   | `--base-url` | адрес модели; `localhost` шлюз видит как `host.docker.internal` | `WORKPERMIT_MODEL_URL` |
+   | `--model` | имя модели на сервере | `WORKPERMIT_MODEL` |
    | `--name` | имя прогона, папка `runs/<прогон>/dsh/`; для сравнения то же, что у прогона другой системы | сегодняшняя дата |
    | `--only` | задачи по имени или номеру через запятую; `8` — вся категория | все 120 |
    | `--again` | прогнать заново задачи с готовой записью | пропускать |
@@ -52,10 +54,12 @@
    | `--turn-minutes` | срок одного сообщения: страховка от зависания, а не мерило | 90 |
    | `--image` | образ агента | `workpermit-dsh:0.2.0-rc.2` |
 
-   Задача с готовой записью пропускается, поэтому прерванный прогон продолжается той же командой.
+   Задача с готовой записью пропускается, поэтому прерванный прогон продолжается той же командой, а прогон по частям
+   (`--only` по категориям) — тем же `--name`: `run.json` дописывает задачи и хранит начало первого запуска. Запуск на
+   другой модели или другом образе в ту же папку прогонщик отклоняет: для них нужен новый прогон.
 
-4. Оценка — командами раздела «Оценка» карточки датасета (`checks.py`, `judge.py`, `report.py` в контейнере
-   `eval/Dockerfile`); судье тоже нужна модель.
+4. Оценка — одной командой `eval/evaluate.py` в контейнере `eval/Dockerfile` (раздел «Оценка» карточки датасета): проверки
+   кода, судья на той же модели, отчёт.
 
 ## Что получается
 

runners/dsh/run.py

@@ -19,10 +19,12 @@
 * выданное — новые документы рабочей папки и изменённые файлы человека; органайзер после задачи и выдача подключённой
   системы снимаются с серверов MCP; всё пишется в ``record.json`` (формат описан в ``eval/checks.py``).
 
-    python run.py <датасет> <папка прогонов> --base-url http://модель:8000/v1 --model <модель> [--name <прогон>]
+    python run.py <датасет> <папка прогонов> [--base-url http://модель:8000/v1] [--model <модель>] [--name <прогон>]
                   [--only <задача или номер>,…] [--again]
 
-Ключ модели — переменная окружения WORKPERMIT_MODEL_KEY; он передаётся контейнеру переменной и нигде не записывается.
+Модель без ключей берётся из переменных окружения WORKPERMIT_MODEL_URL и WORKPERMIT_MODEL, общих с судьёй
+(``eval/judge.py``, ``eval/evaluate.py``). Ключ модели — переменная WORKPERMIT_MODEL_KEY; он передаётся контейнеру
+переменной и нигде не записывается.
 Образ агента: ``docker build -t workpermit-dsh:0.2.0-rc.2 runners/dsh``.
 """
 
@@ -45,6 +47,7 @@ HERE = Path(__file__).resolve().parent
 SYSTEM = "dsh"
 IMAGE = "workpermit-dsh:0.2.0-rc.2"
 KEY_ENV = "WORKPERMIT_MODEL_KEY"
+NO_KEY = "none"
 NETWORK = "workpermit-offline"
 GATE = "workpermit-model-gate"
 GATE_VERSION = "one-image-2"
@@ -228,8 +231,10 @@ def turn(text: str, session: str | None, folder: Path, image: str, timeout: floa
     if session:
         command += ["--session-id", session]
     started = time.monotonic()
+    # Без ключа агент не обращается к модели вовсе (MISSING_CREDENTIAL), поэтому ключ «none»: сервер модели без ключа
+    # принимает любой, как у судьи (eval/judge.py).
     process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                               env={**os.environ, KEY_ENV: os.environ.get(KEY_ENV, "")})
+                               env={**os.environ, KEY_ENV: os.environ.get(KEY_ENV) or NO_KEY})
     failure = None
     try:
         out, err = process.communicate(text.encode("utf-8"), timeout=timeout)
@@ -425,12 +430,32 @@ def _now(zone: str | None) -> datetime:
         return datetime.now().astimezone()
 
 
+def write_manifest(root: Path, args: argparse.Namespace, task_ids: list[str]) -> str | None:
+    """Сведения о прогоне, ``run.json``: прогон идёт по частям (категория за категорией, продолжение после сбоя), поэтому
+    запуск в ту же папку дописывает свои задачи и сохраняет начало первого запуска, по нему сайт называет дату прогона.
+    Модель и образ агента у прогона одни: запуск с другими в ту же папку смешал бы ответы в одном итоге и отклоняется.
+    Возвращает причину отказа или None."""
+    path = root / "run.json"
+    earlier = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+    for key, value in (("model", args.model), ("image", args.image)):
+        if earlier.get(key) not in (None, value):
+            return (f"прогон в {root} начат с {key} {earlier[key]}, а сейчас {value}: для другой модели или образа начните "
+                    f"новый прогон (--name)")
+    tasks = list(dict.fromkeys([*earlier.get("tasks", []), *task_ids]))
+    path.write_text(json.dumps({"system": SYSTEM, "model": args.model, "image": args.image, "context": args.context,
+                                "max_tokens": args.max_tokens,
+                                "started": earlier.get("started") or datetime.now().astimezone().isoformat(timespec="seconds"),
+                                "tasks": tasks}, ensure_ascii=False, indent=1), encoding="utf-8")
+    return None
+
+
 def main(argv: list[str]) -> int:
     parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument("dataset")
     parser.add_argument("runs")
-    parser.add_argument("--base-url", required=True, help="адрес модели, совместимый с OpenAI: http://host:8000/v1")
-    parser.add_argument("--model", required=True)
+    parser.add_argument("--base-url", default=os.environ.get("WORKPERMIT_MODEL_URL") or None,
+                        help="адрес модели, совместимый с OpenAI: http://host:8000/v1; по умолчанию WORKPERMIT_MODEL_URL")
+    parser.add_argument("--model", default=os.environ.get("WORKPERMIT_MODEL") or None, help="имя модели; по умолчанию WORKPERMIT_MODEL")
     parser.add_argument("--name", default=datetime.now().strftime("%Y%m%d"))
     parser.add_argument("--only", help="задачи по имени или номеру через запятую; номер категории берёт её целиком")
     parser.add_argument("--again", action="store_true", help="прогнать заново задачи с готовой записью")
@@ -439,6 +464,8 @@ def main(argv: list[str]) -> int:
     parser.add_argument("--max-tokens", type=int, default=8_192, help="предел ответа модели за обращение")
     parser.add_argument("--turn-minutes", type=float, default=90, help="срок одного сообщения: страховка от зависания")
     args = parser.parse_args(argv[1:])
+    if not args.base_url or not args.model:
+        parser.error("модель не задана: --base-url и --model или переменные WORKPERMIT_MODEL_URL и WORKPERMIT_MODEL")
 
     try:
         ready = docker("image", "inspect", args.image)
@@ -449,16 +476,18 @@ def main(argv: list[str]) -> int:
         print(f"Нет образа {args.image}: соберите его командой\n  docker build -t {args.image} {HERE}\n{ready.stderr.strip()}", file=sys.stderr)
         return 2
     if KEY_ENV not in os.environ:
-        print(f"Переменная {KEY_ENV} не задана: агент обратится к модели без ключа.", file=sys.stderr)
+        print(f"Переменная {KEY_ENV} не задана: агент обратится к модели с ключом «{NO_KEY}», его принимает сервер без ключа.",
+              file=sys.stderr)
 
     only = [o.strip() for o in args.only.split(",")] if args.only else None
     tasks = [t for t in load_tasks(Path(args.dataset))
              if only is None or any(o in (t["id"], t["number"]) or t["number"].startswith(o + ".") for o in only)]
     root = Path(args.runs) / args.name / SYSTEM
     root.mkdir(parents=True, exist_ok=True)
-    (root / "run.json").write_text(json.dumps({"system": SYSTEM, "model": args.model, "image": args.image, "context": args.context,
-                                               "max_tokens": args.max_tokens, "started": datetime.now().astimezone().isoformat(timespec="seconds"),
-                                               "tasks": [t["id"] for t in tasks]}, ensure_ascii=False, indent=1), encoding="utf-8")
+    refusal = write_manifest(root, args, [t["id"] for t in tasks])
+    if refusal:
+        print(refusal, file=sys.stderr)
+        return 2
     model_url = model_gate(args.base_url, args.image)
     print(f"{SYSTEM}: задач {len(tasks)} → {root.resolve()}")
     failed = 0

runners/dsh/test_dsh.py

@@ -210,6 +210,22 @@ class Runner(unittest.TestCase):
         run.add_file(record, folder, "Отчёты_Итог_ март.docx", b"2")
         self.assertEqual(["files/Отчёты_Итог_ март.docx", "files/Отчёты_Итог_ март (2).docx"], [f["path"] for f in record["files"]])
 
+    def test_run_in_parts_keeps_the_first_start_and_all_tasks(self):
+        root = Path(tempfile.mkdtemp())
+        args = run.argparse.Namespace(model="qwen", image="dsh:1", context=64000, max_tokens=8192)
+        self.assertIsNone(run.write_manifest(root, args, ["a", "b"]))
+        first = json.loads((root / "run.json").read_text(encoding="utf-8"))["started"]
+        self.assertIsNone(run.write_manifest(root, args, ["b", "c"]))
+        manifest = json.loads((root / "run.json").read_text(encoding="utf-8"))
+        self.assertEqual((first, ["a", "b", "c"]), (manifest["started"], manifest["tasks"]))
+
+    def test_other_model_in_the_same_run_is_refused(self):
+        root = Path(tempfile.mkdtemp())
+        run.write_manifest(root, run.argparse.Namespace(model="qwen", image="dsh:1", context=64000, max_tokens=8192), ["a"])
+        refusal = run.write_manifest(root, run.argparse.Namespace(model="other", image="dsh:1", context=64000, max_tokens=8192), ["b"])
+        self.assertIn("новый прогон", refusal)
+        self.assertEqual(["a"], json.loads((root / "run.json").read_text(encoding="utf-8"))["tasks"])
+
 
 if __name__ == "__main__":
     unittest.main()