"""Прогон задач WorkPermit агентом DeepSeek Harness (dsh) в безголовом режиме. Для прогона нужен только датасет: кода
сравниваемых систем не нужно.

Агент выполняет команды оболочки без подтверждения, поэтому работает только в контейнере (``Dockerfile`` рядом) во
внутренней сети Docker без выхода наружу. Модель он видит через шлюз (``gate.js``): контейнер, который пересылает запросы
на один адрес модели и оставляет в запросе одно, последнее изображение (сервер модели принимает одно за запрос). Рядом,
в той же сети, работают серверы MCP задачи (``desk/server.py``): подключённая система (двойник 1С, Jira или GitHub),
долговременная память и органайзер человека; агент подключает их плагином ``dsh-mcp-client``.

Задача идёт так же, как у любой системы бенчмарка:

* материалы ложатся в рабочую папку агента по местам человека: «Вложения» (приходят со своим сообщением), «База знаний
  «…»», «Мои файлы»; к словам человека добавляется одна строка о том, где они и куда класть готовые файлы;
* сообщения одного разговора идут одной сессией агента (``--session-id``), другого разговора — новой; память между
  разговорами — сервер памяти;
* на вопрос агента уходит ответ человека, не больше двух раз: заготовленный задачей (``reply_if_asked``), а после
  последнего сообщения, если вопрос не верный исход задачи, общий «Других сведений у меня нет. Сделай по тому, что есть.»;
  вопросом считается ответ, который кончается вопросительным знаком и не изменил ни одного документа в папке;
* выданное — новые документы рабочей папки и изменённые файлы человека; органайзер после задачи и выдача подключённой
  системы снимаются с серверов MCP; всё пишется в ``record.json`` (формат описан в ``eval/checks.py``).

    python run.py <датасет> <папка прогонов> [--base-url http://модель:8000/v1] [--model <модель>] [--name <прогон>]
                  [--only <задача или номер>,…] [--again]

Модель без ключей берётся из переменных окружения 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``.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import os
import shutil
import subprocess
import sys
import time
import uuid
from datetime import datetime
from pathlib import Path
from urllib.parse import urlsplit

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"
DESK_PORT = 8080
DEFAULT_REPLY = "Других сведений у меня нет. Сделай по тому, что есть."
DELIVERED = {".docx", ".xlsx", ".pdf", ".pptx", ".csv", ".md", ".txt"}
SYSTEMS = {"onec", "jira", "github"}
INVALID = set('"<>|:*?\\/') | {chr(c) for c in range(32)}


# ── Задачи датасета ──────────────────────────────────────────────────────────────────────────────────────────────

def _files(dataset: Path, entries: list[dict]) -> list[dict]:
    """Файлы материалов, сверенные по SHA-256 с датасетом: любая система получает байт в байт опубликованное."""
    result = []
    for entry in entries:
        path = dataset / entry["path"]
        sha = hashlib.sha256(path.read_bytes()).hexdigest()
        if sha != entry["sha256"]:
            raise RuntimeError(f"SHA-256 файла «{path}» не совпадает с датасетом: {sha} ≠ {entry['sha256']}")
        result.append({"name": entry["name"], "path": path, "sha256": sha})
    return result


def load_tasks(dataset: Path) -> list[dict]:
    corpora: dict[str, tuple] = {}
    tasks = []
    for line in (dataset / "data" / "tasks.jsonl").read_text(encoding="utf-8").splitlines():
        if not line.strip():
            continue
        task = json.loads(line)
        bases, my_files = [], _files(dataset, task["my_files"])
        if task.get("corpus"):
            key = task["corpus"]["id"]
            if key not in corpora:
                manifest = json.loads((dataset / "corpora" / key / "manifest.json").read_text(encoding="utf-8"))
                corpora[key] = (manifest["title"], manifest["placement"], _files(dataset, manifest["files"]))
            title, placement, files = corpora[key]
            if placement == "knowledge_base":
                bases.append((title, files))
            else:
                my_files = files + my_files
        bases += [(base["name"], _files(dataset, base["files"])) for base in task["knowledge_bases"]]
        turns = [{"text": t["text"], "attachments": _files(dataset, t["attachments"]), "chat": t.get("chat") or "main"} for t in task["turns"]]
        tasks.append({**task, "bases": bases, "my": my_files, "messages": turns,
                      "expects_question": any(c.get("kind") == "asked" for c in task.get("checks", []))})
    return tasks


def reply_after(task: dict, index: int) -> str | None:
    """Ответ человека на вопрос после сообщения ``index``: заготовленный задачей — после любого сообщения; общий — только
    после последнего и когда вопрос не верный исход задачи. После сообщения, за которым идёт следующее, человек не
    отвечает на вопрос, а пишет дальше по сценарию."""
    if task.get("reply_if_asked"):
        return task["reply_if_asked"]
    return None if task["expects_question"] or index != len(task["messages"]) - 1 else DEFAULT_REPLY


def request(task: dict, turn: dict) -> str:
    """Слова человека и строка о том, где лежат материалы и куда класть готовые файлы."""
    where = []
    if turn["attachments"]:
        where.append("приложенные к этому сообщению файлы лежат в папке «Вложения»")
    where += [f"документы базы знаний «{name}» лежат в папке «База знаний «{name}»»" for name, _ in task["bases"]]
    if task["my"]:
        where.append("файлы хранилища человека лежат в папке «Мои файлы»")
    line = f"В рабочей папке: {'; '.join(where)}. " if where else ""
    return f"{turn['text']}\n\n{line}Готовые файлы сохраняй в рабочую папку."


# ── Docker ───────────────────────────────────────────────────────────────────────────────────────────────────────

def docker(*args: str, check: bool = False) -> subprocess.CompletedProcess:
    done = subprocess.run(["docker", *args], capture_output=True, text=True, encoding="utf-8", errors="replace")
    if check and done.returncode != 0:
        raise RuntimeError(f"docker {' '.join(args[:2])}: {(done.stdout + done.stderr).strip()}")
    return done


def model_gate(base_url: str, image: str) -> str:
    """Адрес модели для агента: шлюз во внутренней сети, единственный выход из неё. Сеть и шлюз создаются один раз;
    шлюз пересоздаётся, если смотрит на другой адрес, устарел или остановлен. Модель на этой же машине (localhost) шлюз
    видит как host.docker.internal: Docker Desktop знает этот адрес сам, а Docker на Linux получает его ключом
    ``--add-host host.docker.internal:host-gateway`` (там сервер модели должен слушать не только 127.0.0.1, а 0.0.0.0 или
    адрес моста docker0). Модель по https шлюз вызывает по https; агенту он отвечает по http внутри сети."""
    if docker("network", "inspect", NETWORK).returncode != 0:
        docker("network", "create", "--internal", NETWORK, check=True)
    url = urlsplit(base_url)
    host = "host.docker.internal" if url.hostname in ("localhost", "127.0.0.1", "::1") else url.hostname
    tls = url.scheme == "https"
    port = url.port or (443 if tls else 80)
    label = f"{url.scheme}://{host}:{port} {GATE_VERSION}"
    state = docker("inspect", "-f", '{{.State.Running}} {{index .Config.Labels "workpermit.target"}}', GATE)
    if state.returncode != 0 or state.stdout.strip() != f"true {label}":
        docker("rm", "-f", GATE)
        docker("run", "-d", "--name", GATE, "--label", f"workpermit.target={label}", "--add-host", "host.docker.internal:host-gateway",
               "-e", f"GATE_HOST={host}", "-e", f"GATE_PORT={port}", "-e", f"GATE_TLS={1 if tls else 0}",
               "--entrypoint", "node", image, "-e", (HERE / "gate.js").read_text(encoding="utf-8"), check=True)
        docker("network", "connect", NETWORK, GATE, check=True)
    path = url.path.rstrip("/")
    return f"http://{GATE}:{port}{path if path.endswith('/v1') else path + '/v1'}"


def start_desk(folder: Path, task: dict, image: str) -> str:
    """Серверы MCP задачи в своём контейнере: агенту видны их инструменты, но не код двойников и не файл состояния."""
    name = f"workpermit-desk-{uuid.uuid4().hex[:12]}"
    state = folder / "desk"
    state.mkdir(parents=True, exist_ok=True)
    args = ["run", "-d", "--name", name, "--network", NETWORK, "-v", f"{state}:/state", "-v", f"{HERE / 'desk'}:/desk:ro",
            "--entrypoint", "python3", image, "/desk/server.py", "--port", str(DESK_PORT), "--state", "/state",
            "--time-zone", task.get("time_zone") or "Europe/Moscow"]
    if task.get("system") in SYSTEMS:
        args += ["--system", task["system"]]
    docker(*args, check=True)
    for _ in range(120):
        if (state / "ready").exists():
            return name
        time.sleep(0.5)
    raise RuntimeError(f"серверы MCP не поднялись: {docker('logs', name).stderr[-2000:]}")


def stop_desk(folder: Path, name: str) -> None:
    logs = docker("logs", name)
    (folder / "desk.log").write_text(logs.stdout + logs.stderr, encoding="utf-8")
    docker("rm", "-f", name)


def patch(model_url: str, model: str, desk: str, task: dict, context: int, max_tokens: int) -> str:
    """Настройки агента: модель стенда (адрес, имя, окно, предел ответа), сжатие истории под малое окно и серверы MCP.

    Сжатие истории (``dsh-compaction-basic``) по умолчанию держит запас в 65 536 токенов сверх ответа: при окне в 64 000
    порог выходит отрицательным, и сжатие не срабатывает ни разу. Для малого окна документация агента велит назначить
    запас самому: 4 096 токенов на неточность его счёта, порог тогда — 80 % окна. Модель объявлена с вводом изображений:
    она мультимодальная, и страницы PDF агент смотрит, переведя их в картинки (poppler в контейнере)."""
    # Записи, которых нет в профиле, накладка добавляет строкой insert; остальные строки заменяют настройки своей записи.
    servers = ["memory", "organizer"] + ([task["system"]] if task.get("system") in SYSTEMS else [])
    entries = "- insert:\n" + "".join(f"""    - id: mcp-{server}
      name: '@deepseek-ai/dsh-mcp-client'
      config:
        serverName: {server}
        transport: streamable-http
        url: http://{desk}:{DESK_PORT}/mcp/{server}
        toolCallTimeoutMs: 120000
        failOnStartupError: true
""" for server in servers)
    return f"""- id: compaction-basic
  name: '@deepseek-ai/dsh-compaction-basic'
  config:
    headroomTokens: 4096
    maxTokens: {max_tokens}
- id: agent-default-model
  name: '@deepseek-ai/dsh-agent-default-model'
  config:
    provider: workpermit-model
    model: '{model}'
- id: llm-pi-ai
  name: '@deepseek-ai/dsh-llm-pi-ai'
  config:
    providers:
      workpermit-model:
        displayName: WorkPermit model
        api: openai-completions
        baseURL: {model_url}
        apiKeyEnv: {KEY_ENV}
        models:
          - id: '{model}'
            name: WorkPermit model
            contextWindow: {context}
            maxTokens: {max_tokens}
            reasoningEfforts: false
            input: [text, image]
{entries}"""


def turn(text: str, session: str | None, folder: Path, image: str, timeout: float) -> tuple[str, float, str | None]:
    """Один ход агента в контейнере над папками задачи: события прогона, время и причина сбоя (None — штатно). С
    ``session`` агент продолжает сохранённую в его доме сессию. События дописываются в ``events.jsonl``."""
    container = f"workpermit-dsh-{uuid.uuid4().hex[:12]}"
    command = ["docker", "run", "--rm", "-i", "--name", container, "--network", NETWORK, "-e", KEY_ENV,
               "-v", f"{folder / 'work'}:/work", "-v", f"{folder / 'config'}:/work-config:ro", "-v", f"{folder / 'home'}:/work-home", image]
    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) or NO_KEY})
    failure = None
    try:
        out, err = process.communicate(text.encode("utf-8"), timeout=timeout)
    except subprocess.TimeoutExpired:
        failure = f"не уложился в {timeout / 60:.0f} мин"
        docker("kill", container)
        out, err = process.communicate()
    elapsed = time.monotonic() - started
    events = out.decode("utf-8", errors="replace")
    with (folder / "events.jsonl").open("a", encoding="utf-8") as log:
        log.write(events)
    with (folder / "stderr.txt").open("a", encoding="utf-8") as log:
        log.write(err.decode("utf-8", errors="replace"))
    if failure is None and process.returncode != 0:
        ended = read_events(events)["ended"]
        failure = f"процесс dsh завершился с кодом {process.returncode}" + (f", ход окончен по причине «{ended}»" if ended else "")
    return events, elapsed, failure


def read_events(events: str) -> dict:
    """Итог хода по событиям: ответ, обращения к модели с токенами, причина окончания, сессия и вызовы средств агента."""
    result = {"answer": "", "calls": 0, "prompt": 0, "completion": 0, "ended": None, "session": None, "tools": []}
    for line in events.splitlines():
        try:
            node = json.loads(line)
        except ValueError:
            continue
        if not isinstance(node, dict):
            continue
        kind = node.get("type")
        if kind == "final":
            result["answer"] = node.get("text") or ""
        elif kind == "status" and node.get("phase") == "step_end":
            usage = node.get("usage") or {}
            result["calls"] += 1
            result["prompt"] += usage.get("inputTokens") or 0
            result["completion"] += usage.get("outputTokens") or 0
        elif kind == "status" and node.get("phase") == "turn_end":
            result["ended"] = (node.get("reason") or {}).get("kind")
        elif kind == "session":
            result["session"] = node.get("sessionId") or result["session"]
        elif kind == "tool_call":
            result["tools"].append((node.get("tool") or "", json.dumps(node.get("input"), ensure_ascii=False)))
    return result


# ── Запись прогона ───────────────────────────────────────────────────────────────────────────────────────────────

def snapshot(work: Path) -> dict[str, str]:
    """Документы рабочей папки с хешами; служебные скрипты агента не в счёт."""
    return {p.relative_to(work).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
            for p in work.rglob("*") if p.is_file() and p.suffix.lower() in DELIVERED}


def asked(answer: str, before: dict, after: dict) -> bool:
    """Вопрос человеку: ответ кончается вопросительным знаком, и ни один документ папки не появился и не изменился."""
    lines = [line for line in answer.split("\n") if line.strip()]
    last = lines[-1].strip().rstrip("*_ ") if lines else ""
    return last.endswith("?") and all(before.get(path) == sha for path, sha in after.items())


def add_file(record: dict, folder: Path, name: str, data: bytes) -> None:
    """Выданный файл — в ``files/`` папки задачи под безопасным именем; запись — с именем, как его видит человек."""
    safe = "_".join("".join("_" if c in INVALID else c for c in part) for part in name.replace("\\", "/").split("/"))
    relative, n = f"files/{safe}", 2
    while any(f["path"] == relative for f in record["files"]):
        stem, suffix = os.path.splitext(safe)
        relative, n = f"files/{stem} ({n}){suffix}", n + 1
    (folder / relative).parent.mkdir(parents=True, exist_ok=True)
    (folder / relative).write_bytes(data)
    record["files"].append({"name": name, "path": relative, "sha256": hashlib.sha256(data).hexdigest()})


def organizer(state_file: Path) -> dict:
    """Органайзер после задачи в том же виде, что у любой системы: напоминания, автоматизации, задачи доски, заметки."""
    data = json.loads(state_file.read_text(encoding="utf-8")) if state_file.exists() else {}

    def job(item: dict) -> dict:
        return {"title": item["text"], "text": item["text"], "at_local": item["at"], "local_time": item["at"][11:16],
                "recurring": item["repeat"] != "none", "cron": None, "repeat": item["repeat"]}

    return {"reminders": [job(x) for x in data.get("reminders", [])], "automations": [job(x) for x in data.get("automations", [])],
            "board_tasks": [{"title": t["title"], "text": t.get("description") or "", "due_local": t.get("due")} for t in data.get("board_tasks", [])],
            "notes": [{"title": n["title"], "text": n["text"]} for n in data.get("notes", [])]}


def actions(tools: list[tuple[str, str]], calls_file: Path) -> list[dict]:
    """Действия агента по порядку. Выдача пишется только у подключённой системы: её данных нет в материалах задачи, и без
    выдачи судья счёл бы выдумкой то, что агент прочёл в двойнике."""
    calls = [json.loads(line) for line in calls_file.read_text(encoding="utf-8").splitlines() if line.strip()] if calls_file.exists() else []
    used = [False] * len(calls)
    result = []
    for name, arguments in tools:
        action = {"kind": "shell" if name == "bash" else "tool", "name": name, "arguments": arguments}
        if name.startswith("mcp__"):
            for i, call in enumerate(calls):
                if not used[i] and name == f"mcp__{call['server']}__{call['tool']}":
                    used[i] = True
                    if call["server"] in SYSTEMS:
                        action["result"] = call["result"]
                    break
        result.append(action)
    return result


def run_task(task: dict, folder: Path, args, model_url: str) -> dict:
    record = {"task_id": task["id"], "system": SYSTEM, "status": "completed", "asked": False, "answer": "", "turns": [], "files": [],
              "actions": [], "storage_after": [], "state": None, "started": None, "seconds": 0.0, "model_calls": 0,
              "prompt_tokens": 0, "completion_tokens": 0, "error": None}
    work, config = folder / "work", folder / "config"
    for sub in (work, config, folder / "home"):
        sub.mkdir(parents=True, exist_ok=True)

    inputs: dict[str, tuple[str, str]] = {}

    def place(relative: str, file: dict) -> None:
        target = work / relative
        target.parent.mkdir(parents=True, exist_ok=True)
        shutil.copyfile(file["path"], target)
        inputs[relative] = (file["name"], file["sha256"])

    for name, files in task["bases"]:
        for file in files:
            place(f"База знаний «{name}»/{file['name']}", file)
    for file in task["my"]:
        place(f"Мои файлы/{file['name']}", file)

    desk = start_desk(folder, task, args.image)
    tools: list[tuple[str, str]] = []
    try:
        (config / "patch.yml").write_text(patch(model_url, args.model, desk, task, args.context, args.max_tokens), encoding="utf-8")
        record["started"] = _now(task.get("time_zone")).isoformat(timespec="seconds")
        sessions: dict[str, str] = {}
        failure = None

        def one(text: str, chat: str, is_reply: bool) -> bool:
            nonlocal failure
            before = snapshot(work)
            events, seconds, error = turn(text, sessions.get(chat), folder, args.image, args.turn_minutes * 60)
            step = read_events(events)
            if step["session"]:
                sessions[chat] = step["session"]
            tools.extend(step["tools"])
            record["model_calls"] += step["calls"]
            record["prompt_tokens"] += step["prompt"]
            record["completion_tokens"] += step["completion"]
            question = asked(step["answer"], before, snapshot(work))
            record["turns"].append({"text": text, "answer": step["answer"], "asked": question, "seconds": round(seconds, 1), "reply": is_reply})
            failure = error or (None if step["answer"].strip() else "агент не дал ответа" + (f" («{step['ended']}»)" if step["ended"] else ""))
            return question

        for index, message in enumerate(task["messages"]):
            for file in message["attachments"]:
                place(f"Вложения/{file['name']}", file)
            question = one(request(task, message), message["chat"], False)
            reply = reply_after(task, index)
            rounds = 0
            while reply is not None and question and failure is None and rounds < 2:
                question = one(reply, message["chat"], True)
                rounds += 1
            if failure is not None:
                break
    finally:
        stop_desk(folder, desk)

    last = record["turns"][-1] if record["turns"] else None
    record["seconds"] = round(sum(t["seconds"] for t in record["turns"]), 1)
    record["answer"] = last["answer"] if last else ""
    record["asked"] = bool(last and last["asked"])
    record["status"] = "failed" if failure else "asked" if record["asked"] else "completed"
    record["error"] = failure

    for path in sorted(p for p in work.rglob("*") if p.is_file()):
        relative = path.relative_to(work).as_posix()
        data = path.read_bytes()
        sha = hashlib.sha256(data).hexdigest()
        if relative in inputs:
            record["storage_after"].append({"name": inputs[relative][0], "sha256": sha})
            if sha != inputs[relative][1]:
                add_file(record, folder, inputs[relative][0], data)
        elif path.suffix.lower() in DELIVERED:
            add_file(record, folder, relative, data)
    record["state"] = organizer(folder / "desk" / "state.json")
    record["actions"] = actions(tools, folder / "desk" / "calls.jsonl")
    return record


def _now(zone: str | None) -> datetime:
    try:
        from zoneinfo import ZoneInfo
        return datetime.now(ZoneInfo(zone)) if zone else datetime.now().astimezone()
    except Exception:  # noqa: BLE001 — нет базы поясов: местное время машины
        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, title in (("model", args.model, "моделью"), ("image", args.image, "образом агента")):
        if earlier.get(key) not in (None, value):
            return (f"прогон в {root} начат с {title} {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", 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="прогнать заново задачи с готовой записью")
    parser.add_argument("--image", default=IMAGE)
    parser.add_argument("--context", type=int, default=64_000, help="окно модели, токенов")
    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)
    except FileNotFoundError:
        print("Docker не найден: нужен Docker Desktop или Docker Engine 20.10+ в PATH.", file=sys.stderr)
        return 2
    if ready.returncode != 0:
        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} не задана: агент обратится к модели с ключом «{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)
    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
    for task in tasks:
        folder = root / task["id"]
        if (folder / "record.json").exists() and not args.again:
            print(f"{task['number']} {task['id']}: запись уже есть")
            continue
        # Остатки прерванного или прежнего прогона задачи не смешиваются с новым: папка уходит в сторону с отметкой времени.
        if folder.exists():
            folder.rename(folder.with_name(f"{folder.name}.{datetime.now():%Y%m%d-%H%M%S}"))
        folder.mkdir(parents=True)
        try:
            record = run_task(task, folder, args, model_url)
        except Exception as error:  # noqa: BLE001 — сбой обвязки пишется записью и не останавливает остальные задачи
            record = {"task_id": task["id"], "system": SYSTEM, "status": "failed", "asked": False, "answer": "", "turns": [], "files": [],
                      "actions": [], "storage_after": [], "state": None, "started": None, "seconds": 0.0, "model_calls": 0,
                      "prompt_tokens": 0, "completion_tokens": 0, "error": f"{type(error).__name__}: {error}"}
        (folder / "record.json").write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
        failed += record["status"] == "failed"
        print(f"{task['number']} {task['id']}: {record['status']}, {record['seconds']} с, обращений {record['model_calls']}, "
              f"файлов {len(record['files'])}" + (f" — {record['error']}" if record["error"] else ""))
    print(f"{SYSTEM}: готово, сбоев {failed}")
    return 0


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