#!/usr/bin/env python3
"""Проба A (промт POLYGON_EDITOR_WIRE_PROBE §A): РЕДАКТОРСКИЙ провод под доктриной закона D39.104.

Отличие от inject_probe.py (тот мерил ТРАНСЛЯТОР-провод): здесь роль — РЕДАКТОР, вход
байт-близко к edit-стадии шиппинг-конфига c1:
  messages = [system(editor.md CORE, few_shot ДРОПНУТ), system(банк-блок), user(text+draft)]
  model=deepseek-v4-pro · temperature=0.4 · max_tokens=16000 · reasoning_effort НЕ СЛАТЬ.
Формат строк блока — как editorLines (membank/memory.go:798-829): "- src → «dst»".

Армы: A0 (без блока) · A1 (единый закон-блок, ВЕРНАЯ строка) · A2 (тот же блок, НЕВЕРНАЯ
строка 元海→«Юаньхай» во ВСЕХ 6 окнах — межоконная консистентность) · AM (метаязыковое окно,
закон+оговорка против закона-без-оговорки) · A5 (посаженные дефекты черновика, без блока).

Черновики — арм B транслятор-сырья research/24 §C ($0, уже персистированы).
Сырьё durable ~/books/gu-zhenren/bank-arbitration/, префикс edp-*.
"""
from __future__ import annotations
import argparse
import json
import os
import re
import sys
import time
import unicodedata
from pathlib import Path

from dotenv import load_dotenv
from openai import OpenAI

REPO = Path("/home/ubuntu/projects/textmachine")
HERE = Path(__file__).resolve().parent
RAW = Path.home() / "books" / "gu-zhenren" / "bank-arbitration"
SRC = Path.home() / "books" / "gu-zhenren" / "coldrun-a" / "guzhenren-ch1-10.gb18030.txt"
load_dotenv(REPO / "eval" / ".env")

sys.path.insert(0, str(HERE))
from inject_probe import TERMS, pick_windows, norm  # noqa: E402  (тот же реестр термов и те же окна)

# --- Провод: ровно edit-стадия pipeline-c1.yaml -------------------------------------------------
MODEL = "deepseek-v4-pro"
TEMPERATURE = 0.4          # pipeline-c1.yaml stages[edit].temperature
MAX_TOKENS = 16000         # models.yaml:166 capabilities.min_max_tokens (флор v4-pro)
FEW_SHOT = False           # pipeline-c1.yaml stages[edit].few_shot: false → блок ---FEWSHOT--- дропается
# reasoning_effort НЕ шлём вовсе: deepseek = ReasoningNone (llm/capability.go:177-180),
# reasoning:"off" в конфиге ⇒ ключа на проводе НЕТ ⇒ вендор-дефолт high (quirks 00 §3а).
PRICE_IN, PRICE_CACHED, PRICE_OUT = 0.435, 0.003625, 0.87  # models.yaml deepseek-v4-pro
HARD_STOP_USD = 0.28       # пре-рег: живой стоп ниже потолка $0.30

EDITOR = REPO / "backend/prompts/zh-ru/editor.md"
TRANSLATOR = REPO / "backend/prompts/zh-ru/translator.md"
USER_SEP = "\n---USER---\n"
FEWSHOT_SEP = "\n---FEWSHOT---\n"

# --- §B: кандидат-редакции заголовков (в движок НЕ вносятся) ------------------------------------
# База — действующий editor_header (backend/internal/lang/data/injection.txt строка 7), дословно.
EDITOR_HEADER_BASE = (
    "КАНОНИЧЕСКИЕ ПЕРЕВОДЫ имён и терминов (в черновике термин исходника слева ДОЛЖЕН быть "
    "передан именно указанной формой справа — приводи к ней любые расхождения, склоняя по "
    "контексту; не вводи иных вариантов и не меняй ничего другого)"
)
CLAUSE = (
    "; глоссарий обязателен для употреблений термина КАК термина: игру слов, разбор знаков, "
    "буквальное прочтение передавай по смыслу пассажа, сохраняя узнаваемость канонической формы"
)
HEADER_LAW_CLAUSE = EDITOR_HEADER_BASE + CLAUSE + ":"   # единый закон-блок §B (A1/A2/AM-clause)
HEADER_LAW_PLAIN = EDITOR_HEADER_BASE + ":"             # закон без оговорки (AM-noclause)

WRONG_TERM = "元海"          # единственный терм, присутствующий во ВСЕХ 6 окнах → метрика консистентности
AM_PARAS = (517, 522)        # метаязыковое окно: 蛊名月光 (имя как имя) + 弯弯如月 (буквальная луна)

RENDER_VARS = {"source_lang": "zh", "target_lang": "ru", "genre": "вебновелла",
               "audience": "взрослые читатели вебновелл", "title": "蛊真人", "venuti": "0.60",
               "honorifics": "keep", "transcription": "palladius", "footnotes": "minimal"}


def strip_comments(s: str) -> str:
    """Зеркало render.go:99-116 (stripPromptComments): SHA берётся с канонической формы."""
    out, rest = [], s
    while True:
        i = rest.find("<!--")
        if i < 0:
            out.append(rest)
            return "".join(out)
        out.append(rest[:i])
        rest = rest[i + 4:]
        j = rest.find("-->")
        if j < 0:
            raise ValueError("unterminated comment")
        rest = rest[j + 3:]


def load_template(path: Path) -> tuple[str, str, str]:
    """Зеркало render.go LoadPromptTemplate: (core system, fewshot, user)."""
    canon = strip_comments(path.read_text(encoding="utf-8"))
    sys_part, user = canon.split(USER_SEP, 1)
    head = sys_part.split(FEWSHOT_SEP, 1)
    core = head[0].strip()
    few = head[1].strip() if len(head) == 2 else ""
    return core, few, user.strip()


def render(tpl: str, text: str, draft: str) -> str:
    """Зеркало render.go Render: ОДИН проход, значения не пере-сканируются."""
    vals = dict(RENDER_VARS, text=text, draft=draft)
    out, rest = [], tpl
    while True:
        i = rest.find("{{")
        if i < 0:
            out.append(rest)
            return "".join(out)
        out.append(rest[:i])
        rest = rest[i:]
        end = rest.find("}}")
        if end < 0:
            raise ValueError("unterminated placeholder")
        name = rest[2:end]
        if name not in vals:
            raise ValueError(f"unknown placeholder {{{{{name}}}}}")
        out.append(vals[name])
        rest = rest[end + 2:]


def editor_messages(text: str, draft: str, block: str | None) -> list[dict]:
    core, few, user_tpl = load_template(EDITOR)
    system = core + ("\n\n" + few if FEW_SHOT and few else "")   # SystemFor(fewShotOn)
    msgs = [{"role": "system", "content": render(system, text, draft)}]
    if block and block.strip():
        msgs.append({"role": "system", "content": block})
    msgs.append({"role": "user", "content": render(user_tpl, text, draft)})
    return msgs


def editor_block(terms: list[str], header: str, wrong: str | None) -> str:
    """Формат editorLines (memory.go:815): '- ' + src + ' → «' + dst + '»'."""
    lines = []
    for t in terms:
        gold, bad, _, _ = TERMS[t]
        dst = bad if t == wrong else gold
        lines.append(f"- {t} → «{dst}»")
    return header + "\n" + "\n".join(lines)


# --- A5: посаженные дефекты черновика (дословный список — во фризе пре-рега) ---------------------
# (класс, что заменить в черновике, на что, regex «дефект ещё в выходе», regex «починено по смыслу»)
DEFECTS = {
    0: [("k1", "также поразительна", "также взгрумительна", r"взгрумительн", r"поразительн|порази|впечатл|изумител|поразит"),
        ("k2", "они не выдержат такого непрерывного расхода",
         "они легко выдержат такой непрерывный расход",
         r"легко выдерж", r"не выдерж|не выстоят|не хват|иссяк|не выносят")],
    1: [("k1", "сокровище природы", "мреязное сокровище природы", r"мреязн", r"сокровищ"),
        ("k2", "на глазах неуклонно поднимался", "на глазах неуклонно опускался",
         r"неуклонно опуска|неуклонно понижа|неуклонно снижа", r"поднима|повыша|нараста|расту|рос\b|привстава|прибыва|подъём|увеличива")],
    2: [("k1", "словно натянутая струна", "словно натянутая струмель", r"струмел", r"струн"),
        ("k2", "Увы, тот так и не показался", "Увы, тот в первую же ночь и показался",
         r"в первую же ночь и показа", r"так и не показа|не появ|не показыва|не давал себя|не показал")],
    3: [("k1", "но при этом необычайно густой", "но при этом необычайно гущавой", r"гущав", r"густ|вязк|плотн"),
        ("k2", "Фан Юань, не оборачиваясь, развернулся и пошёл обратно",
         "Фан Юань обернулся и остался стоять на месте",
         r"остал\w{0,3} стоять на месте", r"развернул|поверн\w+ (назад|обратно)|пошёл обратно|двинул\w* обратно|побрёл обратно|пошел обратно")],
    4: [("k1", "волна дерзновенной отваги", "волна дерзновяжной отваги", r"дерзновяжн", r"дерзнов|отваг|воодушевл|решимост"),
        ("k2", "была вполне приемлемой платой", "была совершенно недопустимой утратой",
         r"недопустим\w* утрат", r"приемлем|допустим|не столь велик|стоила того|можно смириться|терпим")],
    5: [("k1", "оттенок суровой удали", "оттенок суровяглой удали", r"суровягл", r"суров|удал|лих|дерзк"),
        ("k2", "он наконец не смог идти дальше", "он зашагал ещё быстрее",
         r"зашагал ещ[её] быстрее", r"не смог идти|не мог идти|остановил|не в силах|дальше не|встал\b|замер")],
}


def planted_draft(k: int, draft: str) -> tuple[str, list]:
    out = draft
    for cls, old, new, bad_rx, fix_rx in DEFECTS[k]:
        if old not in out:
            raise SystemExit(f"w{k}: посадка не нашла якорь {old!r} в черновике")
        out = out.replace(old, new, 1)
    return out, DEFECTS[k]


# --- окна ---------------------------------------------------------------------------------------
def draft_of(k: int) -> str:
    return json.load(open(RAW / f"inj-w{k}-B.json", encoding="utf-8"))["content"]


def am_window() -> tuple[str, list[str]]:
    paras = [p for p in SRC.read_text(encoding="gb18030").split("\n") if p.strip()]
    buf = "\n".join(paras[AM_PARAS[0]:AM_PARAS[1]]) + "\n"
    terms = [t for t in TERMS if t in buf]
    return buf, terms


# --- вызовы -------------------------------------------------------------------------------------
def client() -> OpenAI:
    return OpenAI(api_key=os.environ["DEEPSEEK_API_KEY"], base_url="https://api.deepseek.com/v1", timeout=900)


def call(cl, msgs, tag, model=MODEL, temperature=TEMPERATURE, max_tokens=MAX_TOKENS,
         extra=None, prices=(PRICE_IN, PRICE_CACHED, PRICE_OUT)) -> dict:
    kw = dict(model=model, messages=msgs, max_tokens=max_tokens, temperature=temperature)
    if extra:
        kw["extra_body"] = extra
    t0 = time.time()
    r = cl.chat.completions.create(**kw)
    ch = r.choices[0]
    u = r.usage
    pt, ct = u.prompt_tokens or 0, u.completion_tokens or 0
    cached = getattr(getattr(u, "prompt_tokens_details", None), "cached_tokens", 0) or 0
    pin, pcache, pout = prices
    cost = (pt - cached) / 1e6 * pin + cached / 1e6 * pcache + ct / 1e6 * pout
    rec = dict(tag=tag, model=model, model_returned=r.model, finish=ch.finish_reason,
               ts=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
               temperature=temperature, max_tokens=max_tokens, extra_body=extra or {},
               prompt_tokens=pt, cached_tokens=cached, completion_tokens=ct,
               reasoning_chars=len(getattr(ch.message, "reasoning_content", None) or ""),
               cost_usd=round(cost, 6), latency_s=round(time.time() - t0, 1),
               messages=msgs, content=ch.message.content or "")
    (RAW / f"{tag}.json").write_text(json.dumps(rec, ensure_ascii=False, indent=1), encoding="utf-8")
    print(f"[{tag}] finish={ch.finish_reason} in={pt}(c{cached}) out={ct} "
          f"${cost:.6f} {rec['latency_s']}s content={len(rec['content'])}c")
    return rec


def slug_check() -> None:
    cl = client()
    ids = [m.id for m in cl.models.list().data]
    print(f"/models deepseek: {ids}")
    if MODEL not in ids:
        raise SystemExit(f"слаг {MODEL} НЕ листится — СТОП")


def build_arms(am_draft: str | None):
    """Полный план вызовов: [(tag, messages, note)]."""
    wins = pick_windows()
    plan = []
    for k, (i, buf, terms) in enumerate(wins):
        d = draft_of(k)
        plan.append((f"edp-A0-w{k}", editor_messages(buf, d, None), "без блока"))
    for k, (i, buf, terms) in enumerate(wins):
        d = draft_of(k)
        plan.append((f"edp-A1-w{k}", editor_messages(buf, d, editor_block(terms, HEADER_LAW_CLAUSE, None)),
                     "закон+оговорка, ВЕРНАЯ"))
    for k, (i, buf, terms) in enumerate(wins):
        d = draft_of(k)
        plan.append((f"edp-A2-w{k}", editor_messages(buf, d, editor_block(terms, HEADER_LAW_CLAUSE, WRONG_TERM)),
                     f"закон+оговорка, НЕВЕРНАЯ {WRONG_TERM}"))
    if am_draft is not None:
        buf, terms = am_window()
        plan.append(("edp-AM-clause", editor_messages(buf, am_draft, editor_block(terms, HEADER_LAW_CLAUSE, None)),
                     "метаязык: закон+оговорка"))
        plan.append(("edp-AM-noclause", editor_messages(buf, am_draft, editor_block(terms, HEADER_LAW_PLAIN, None)),
                     "метаязык: закон БЕЗ оговорки"))
    for k, (i, buf, terms) in enumerate(wins):
        d, _ = planted_draft(k, draft_of(k))
        plan.append((f"edp-A5-w{k}", editor_messages(buf, d, None), "посаженные дефекты, без блока"))
    return plan


def cmd_plan():
    """Смета ДО первого платного вызова. Токены — калибровка cl100k против фактических
    prompt_tokens сырья §C (печатается), выход — полоса от содержательного до потолка."""
    import tiktoken
    enc = tiktoken.get_encoding("cl100k_base")

    # --- калибровка на фактическом сырье §C (транслятор-армы, prompt_tokens известны) ---
    core_t, few_t, user_t = load_template(TRANSLATOR)
    ratios = []
    for k, (i, buf, terms) in enumerate(pick_windows()):
        rec = json.load(open(RAW / f"inj-w{k}-B.json", encoding="utf-8"))
        s = render(core_t, buf, "") + "\n" + rec["injection"] + "\n" + rec["user"]
        ratios.append(rec["prompt_tokens"] / len(enc.encode(s)))
    calib = sum(ratios) / len(ratios)
    print(f"калибровка cl100k→deepseek prompt_tokens: ×{calib:.3f} (по 6 вызовам §C, разброс "
          f"{min(ratios):.3f}..{max(ratios):.3f})")

    plan = build_arms(am_draft="ЗАГЛУШКА " * 200)
    tot_in = 0
    for tag, msgs, note in plan:
        n = int(len(enc.encode("\n".join(m["content"] for m in msgs))) * calib)
        tot_in += n
        print(f"  {tag:18s} in≈{n:5d} ток. — {note}")
    # выход: нижняя оценка — только содержательный текст (≈ длина черновика), верхняя — потолок
    lo_out = 26 * 900
    mid_out = 26 * 4000
    hi_out = 26 * MAX_TOKENS
    def money(o):
        return tot_in / 1e6 * PRICE_IN + o / 1e6 * PRICE_OUT
    print(f"\nвсего вход ≈{tot_in} ток. → ${tot_in/1e6*PRICE_IN:.4f}")
    print(f"выход: нижняя {lo_out} ток. ${money(lo_out):.4f} · ожидаемая {mid_out} ток. "
          f"${money(mid_out):.4f} · АБСОЛЮТНЫЙ ПОТОЛОК {hi_out} ток. ${money(hi_out):.4f}")
    print(f"ПОТОЛОК ПРОБЫ $0.30; живой стоп харнесса ${HARD_STOP_USD} (проверяется ПЕРЕД каждым вызовом)")
    print(f"+ 1 транслятор-вызов (черновик AM-окна, deepseek-v4-flash low) ≈ $0.002")


def cmd_amdraft():
    """Черновик метаязыкового окна тем же проводом, что арм B §C (flash, low, temp 0, верный блок)."""
    from inject_probe import render_translator, block_for
    buf, terms = am_window()
    system, user = render_translator(buf)
    inj = block_for(terms, wrong=None, marked=False)
    cl = OpenAI(api_key=os.environ["DEEPSEEK_API_KEY"], base_url="https://api.deepseek.com/v1", timeout=600)
    msgs = [{"role": "system", "content": system}, {"role": "system", "content": inj},
            {"role": "user", "content": user}]
    call(cl, msgs, "edp-AMdraft", model="deepseek-v4-flash", temperature=0, max_tokens=16000,
         extra={"reasoning_effort": "low"}, prices=(0.14, 0.0028, 0.28))


def cmd_run(only: list[str]):
    am = None
    f = RAW / "edp-AMdraft.json"
    if f.exists():
        am = json.load(open(f, encoding="utf-8"))["content"]
        planted = RAW / "edp-AMdraft-planted.txt"
        if planted.exists():          # пре-рег ветка «черновик канонизировал» → посадка объявлена
            am = planted.read_text(encoding="utf-8")
    plan = [p for p in build_arms(am) if not only or any(p[0].startswith(f"edp-{o}") for o in only)]
    cl = client()
    total = 0.0
    for tag, msgs, note in plan:
        if (RAW / f"{tag}.json").exists():
            print(f"[{tag}] уже персистирован — пропуск")
            continue
        if total >= HARD_STOP_USD:
            print(f"СТОП: накоплено ${total:.4f} ≥ ${HARD_STOP_USD}")
            break
        rec = call(cl, msgs, tag)
        total += rec["cost_usd"]
        time.sleep(0.5)
    print(f"TOTAL этого запуска: ${total:.6f}")


# --- скоринг ------------------------------------------------------------------------------------
def hits(out_norm: str, term: str) -> tuple[bool, bool]:
    """gold/wrong по regex харнесса. ⚠ РАЗВЯЗКА КОНФАУНДА (оговорка приёмки research/24 (а)):
    голд-rx 真元 (r'истинн\\w* ци') матчится ВНУТРИ верного перевода 元海 «море истинной ци».
    Перед поиском 真元 вырезаем все вхождения голд-формы 元海."""
    gold, bad, grx, brx = TERMS[term]
    hay = out_norm
    if term == "真元":
        hay = re.sub(TERMS["元海"][2], " ", hay)
    return bool(re.search(grx, hay)), bool(re.search(brx, out_norm))


def out_of(tag: str) -> str | None:
    f = RAW / f"{tag}.json"
    if not f.exists():
        return None
    return norm(json.load(open(f, encoding="utf-8"))["content"])


def cmd_score():
    wins = pick_windows()
    print("=== A0/A1/A2: следование закону по ВЕРНЫМ строкам блока (терм ≠ 元海) ===")
    per_arm = {}
    for arm in ("A0", "A1", "A2"):
        g = n = 0
        detail = []
        for k, (i, buf, terms) in enumerate(wins):
            o = out_of(f"edp-{arm}-w{k}")
            if o is None:
                continue
            for t in terms:
                if t == WRONG_TERM:
                    continue
                gh, wh = hits(o, t)
                g += gh
                n += 1
                detail.append((k, t, gh, wh))
        per_arm[arm] = (g, n, detail)
        print(f"  арм {arm}: {g}/{n} канонических форм в выходе")
    print("\n=== строка 元海 (в A2 инъецирована НЕВЕРНОЙ «Юаньхай») ===")
    for arm in ("A0", "A1", "A2"):
        rows = []
        for k, (i, buf, terms) in enumerate(wins):
            o = out_of(f"edp-{arm}-w{k}")
            if o is None:
                continue
            gh, wh = hits(o, WRONG_TERM)
            rows.append((k, gh, wh))
        gold_n = sum(1 for _, gh, _ in rows if gh)
        wrong_n = sum(1 for _, _, wh in rows if wh)
        print(f"  арм {arm}: gold {gold_n}/{len(rows)} · wrong {wrong_n}/{len(rows)}  "
              + " ".join(f"w{k}:(g={int(gh)},w={int(wh)})" for k, gh, wh in rows))
    print("\n  консистентность A2 (одна строка, 6 окон): "
          + describe_consistency([(k,) + hits(out_of(f"edp-A2-w{k}"), WRONG_TERM)
                                  for k in range(6) if out_of(f"edp-A2-w{k}") is not None]))
    print("\n=== A5: фикс-рейт посаженных дефектов (арм без блока) ===")
    for cls in ("k1", "k2"):
        fixed = tot = 0
        rows = []
        for k in range(6):
            o = out_of(f"edp-A5-w{k}")
            if o is None:
                continue
            for c, old, new, bad_rx, fix_rx in DEFECTS[k]:
                if c != cls:
                    continue
                still = bool(re.search(bad_rx, o))
                restored = bool(re.search(fix_rx, o))
                tot += 1
                fixed += (not still)
                rows.append(f"w{k}:{'FIX' if not still else 'ЖИВ'}{'/восст' if restored else ''}")
        print(f"  класс {cls}: исправлено {fixed}/{tot}   " + " ".join(rows))
    print("\n=== AM: метаязыковое окно ===")
    for tag in ("edp-AM-clause", "edp-AM-noclause"):
        f = RAW / f"{tag}.json"
        if not f.exists():
            continue
        c = json.load(open(f, encoding="utf-8"))["content"]
        print(f"--- {tag} ---\n{c}\n")


def cmd_eyes():
    """Глазная сверка A5: по каждой из 12 посадок печатает посаженную фразу и ОКРЕСТНОСТЬ
    в выходе редактора. Пре-рег: при расхождении с regex авторитет — глаз."""
    for k in range(6):
        f = RAW / f"edp-A5-w{k}.json"
        if not f.exists():
            continue
        out = json.load(open(f, encoding="utf-8"))["content"]
        print(f"\n########## w{k} ##########")
        for cls, old, new, bad_rx, fix_rx in DEFECTS[k]:
            n = norm(out)
            still = bool(re.search(bad_rx, n))
            restored = bool(re.search(fix_rx, n))
            print(f"--- {cls}: посажено {new!r}")
            print(f"    было в черновике: {old!r}")
            print(f"    regex: дефект_жив={still} смысл_восстановлен={restored}")
            # окрестность: ищем по якорному слову посадки и по якорю оригинала
            anchors = [w for w in re.split(r"\W+", new) if len(w) > 4][:4]
            shown = set()
            for a in anchors:
                for m in re.finditer(re.escape(a), out, re.I):
                    s = max(0, m.start() - 120)
                    frag = out[s:m.end() + 120].replace("\n", " ")
                    if frag not in shown:
                        shown.add(frag)
                        print(f"    …{frag}…")
                    break
            if not shown:
                print("    (якорей посадки в выходе нет — фрагмент переписан целиком)")


def describe_consistency(rows) -> str:
    if not rows:
        return "нет данных"
    accepted = sum(1 for _, gh, wh in rows if wh)
    displaced = sum(1 for _, gh, wh in rows if wh and not gh)
    return (f"неверная форма принята в {accepted}/{len(rows)} окнах, из них полностью вытеснила "
            f"верную в {displaced}/{len(rows)}; единогласие "
            f"{max(accepted, len(rows) - accepted)}/{len(rows)}")


def cmd_selfcheck():
    """Ре-ран §C по персистированному сырью: (1) воспроизводим таблицу research/24 §C
    ТЕМ ЖЕ методом, (2) показываем эффект развязки конфаунда 真元/元海."""
    wins = pick_windows()
    from inject_probe import WRONG_PRIORITY
    for fix in (False, True):
        print(f"--- конфаунд {'РАЗВЯЗАН' if fix else 'как в §C'} ---")
        for arm in "ABCD":
            g = n = 0
            wg = wn = 0
            for k, (i, buf, terms) in enumerate(wins):
                cand = [t for t in WRONG_PRIORITY if t in terms]
                wrong = cand[k % len(cand)]
                f = RAW / f"inj-w{k}-{arm}.json"
                if not f.exists():
                    continue
                o = norm(json.load(open(f, encoding="utf-8"))["content"])
                for t in terms:
                    gold, bad, grx, brx = TERMS[t]
                    hay = o
                    if fix and t == "真元":
                        hay = re.sub(TERMS["元海"][2], " ", hay)
                    gh, wh = bool(re.search(grx, hay)), bool(re.search(brx, o))
                    if t == wrong:
                        wn += 1
                        wg += wh
                    else:
                        n += 1
                        g += gh
            print(f"  арм {arm}: верные строки {g}/{n} · неверная принята {wg}/{wn}")


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--plan", action="store_true", help="смета, без вызовов")
    ap.add_argument("--slugcheck", action="store_true")
    ap.add_argument("--amdraft", action="store_true", help="1 транслятор-вызов: черновик AM-окна")
    ap.add_argument("--run", nargs="*", default=None, help="A0 A1 A2 AM A5 (пусто = все)")
    ap.add_argument("--score", action="store_true")
    ap.add_argument("--selfcheck", action="store_true", help="ре-ран §C по сырью, $0")
    ap.add_argument("--eyes", action="store_true", help="глазная сверка 12 посадок A5")
    ap.add_argument("--dump", help="напечатать messages одного тега (байт-сверка провода)")
    a = ap.parse_args()
    if a.plan:
        cmd_plan()
    elif a.slugcheck:
        slug_check()
    elif a.amdraft:
        cmd_amdraft()
    elif a.run is not None:
        cmd_run(a.run)
    elif a.score:
        cmd_score()
    elif a.selfcheck:
        cmd_selfcheck()
    elif a.eyes:
        cmd_eyes()
    elif a.dump:
        am = None
        f = RAW / "edp-AMdraft.json"
        if f.exists():
            am = json.load(open(f, encoding="utf-8"))["content"]
        for tag, msgs, note in build_arms(am or "ЧЕРНОВИК-ЗАГЛУШКА"):
            if tag == a.dump:
                for m in msgs:
                    print(f"----- role={m['role']} ({len(m['content'])} симв) -----")
                    print(m["content"])
    else:
        ap.print_help()


if __name__ == "__main__":
    main()