arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/harness/verify/ci/gates/backends/check_backends.py

@@ -0,0 +1,1248 @@
+#!/usr/bin/env python3
+"""Ворота кодогенерации (DECISION-0188).
+
+План строится из CLIR один раз и печатается в целевые языки. Каждый бэкенд
+исполняет L0-векторы и обязан совпасть С ГОЛДЕНОМ и С ОСТАЛЬНЫМИ бэкендами.
+
+Три исхода исполнения различаются протоколом выхода раннера, а не одним
+ненулевым кодом: ответ (код 0, JSON), названный отказ среза (код 3, JSON
+`{"refused": текст}`) и крах (любой другой код). Крах валит ворота. Отказ
+обязан быть единогласным и дословно одинаковым у всех целей: отказ одной
+цели при ответе другой — расхождение, а не «отказ рантайма». До этого
+протокола ворота прерывали вектор на первом ненулевом коде и не видели, что
+на `ERR-E0046-CASE-ARG-TYPE` две цели отвечают `TRUE_ONLY` против голдена.
+
+Поражаемый слой (DECISION-0237): векторы `layer: L1` идут тем же путём, но
+со своим полом храповика; голден без результата у L1-вектора обязан быть
+структурным отказом плана с той же причиной. Фикстуры `l1_fixtures.py`
+держат решающую норму канарейками и порядок — перестановкой.
+
+Исход каждого L0- и L1-вектора закреплён в манифесте `verify/ci/data/backends-vectors.json`:
+совпадение, отказ плана, вид запроса, голден без результата, отказ рантайма.
+Закреплённый исход обязан повториться; закреплённый вектор обязан
+существовать; незакреплённое совпадение — ошибка регистрации
+(`--write-manifest`). Одно число исполненных векторов позволило бы потерять
+старый случай и компенсировать его новым, поэтому пол `MIN_CHECKED` остался
+лишь второй защитой.
+
+Цели — каталоги `engines/backends/targets/<цель>/` с дескриптором в
+`emit.py` (`available`, `MODEL`, `layout`, `build`, `run`). По умолчанию
+исполняются `ts,py,go`; `--targets` выбирает другие или `all`. Цель Python не
+требует тулчейна и проверяется ВСЕГДА: без неё ворота сообщали бы «зелено»,
+не исполнив ни одного бэкенда. Отсутствие тулчейна НАЗЫВАЕТСЯ в отчёте;
+`--require` делает его отказом ворот.
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import copy
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[4]
+BACKENDS = ROOT / "engines" / "backends"
+VECTORS = ROOT / "verify" / "vectors"
+MANIFEST = ROOT / "verify" / "ci" / "data" / "backends-vectors.json"
+MANIFEST_FORMAT = "law.backends-vectors/1"
+CERT = BACKENDS / "runtime-cert.json"
+REFUSED_EXIT = 3
+DEFAULT_TARGETS = "ts,py,go"
+
+sys.path.insert(0, str(BACKENDS))
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import plan as P  # noqa: E402
+import deliver as D  # noqa: E402
+import l1_fixtures as FX  # noqa: E402
+
+# Пол храповика: столько векторов обязаны исполниться и совпасть. Вторая защита
+# после манифеста: манифест ловит подмену случая, пол — массовую потерю.
+# 16.09.2026 (DECISION-0266–0268, перепин манифеста после 0252/0256/0259): 82 → 225.
+# 16.09.2026 (DECISION-0270, условный терм и вычисляемый аргумент тела): 225 → 234.
+# 16.09.2026 (DECISION-0273, функции §46, параметры A3, let/match): 234 → 251.
+# 16.09.2026 (DECISION-0274, канал суждения §47.3): 251 → 255.
+MIN_CHECKED = 255
+# Пол поражаемого слоя (DECISION-0237): совпадения L1-векторов плюс голдены
+# без результата, сверенные как структурный отказ. Отдельный от L0: рост
+# одного слоя не должен прятать потерю в другом.
+# 16.09.2026 (DECISION-0269, датированные приоритеты): 37 → 46.
+# 16.09.2026 (DECISION-0270): 46 → 59.
+# 16.09.2026 (DECISION-0274, канал суждения §47.3): 59 → 60.
+MIN_CHECKED_L1 = 60
+# Пол нормативных позиций (DECISION-0242): совпадения векторов слоёв L2 и L3,
+# исполняющих позиции; отдельный от L0 и L1.
+# 16.09.2026 (DECISION-0274, канал суждения §47.3: LAY-L2-JUDGMENT-*, E-0100/E-0120/E-0179, позиции): 35 → 71.
+MIN_CHECKED_L2 = 71
+
+# Голден без результата у L1-вектора — фатальная диагностика оракула до
+# вывода. Срез обязан отказать планом по той же причине; иной отказ или
+# построенный план — ошибка ворот, а не «голден без результата».
+STRUCTURAL = {
+    "NON_EXECUTABLE_UNSTRATIFIED": P.UNSTRATIFIED,
+    "NON_EXECUTABLE_STRATUM_BARRIER": "дефитер без обычного кандидата той же полярности "
+                                      "(§110 п. 5, NON_EXECUTABLE_STRATUM_BARRIER)",
+    "LDC-E4101": "несвязанная переменная в голове",
+}
+
+# Коды issues, которые срез порождает сам: по ним ответ сверяется с голденом,
+# а не только между целями. Иначе KEY_CONFLICT, не влияющий на статус, был бы
+# невидим воротам: модуль, молча не считающий ключи §45.1, совпадал бы с
+# голденом по статусу и с соседями по пустому списку. Остальные диагностики
+# голдена срез не порождает и не сверяет.
+BACKEND_ISSUES = {"TYPE_ERROR", "KEY_CONFLICT", "DATE_INSTANT_MISMATCH", "UNSUPPORTED_IN_SLICE",
+                  # DECISION-0274: ответ судьи §47.3.1 не от того органа / не по форме.
+                  "JUDGMENT_AUTHORITY_MISMATCH", "JUDGMENT_PAYLOAD_MISMATCH",
+                  # DECISION-0252: ошибки значения §58 в правилах плана 0.12 и в вопросе `term`.
+                  "DIVISION_BY_ZERO", "INEXACT_DIVISION", "CURRENCY_MISMATCH",
+                  # DECISION-0242 K1: эффекты полномочий §127–§128.
+                  "POWER_INVALID_EXERCISE", "EFFECT_BLOCKED_BY_IMMUNITY", "UNRESOLVED_NORMATIVE_CONFLICT",
+                  # DECISION-0239 G3: ошибка значения агрегата в правиле — issue и пропуск.
+                  "EMPTY_AGGREGATE", "MONOTONE_GUARD_NEGATIVE_ADDEND",
+                  # DECISION-0245: ошибки календаря §85/§86 в термах правил.
+                  "MISSING_POLICY", "DEADLINE_POLICY_INVALID", "MISSING_CALENDAR", "CALENDAR_OUT_OF_RANGE",
+                  "CALENDAR_DATASET_INVALID", "CALENDAR_DATASET_HASH_MISMATCH"}
+
+# Пакеты корпуса с поверхностью API (DECISION-0234): снимки CLIR, у которых
+# план строит вопросы. Проверка API — раннер против API одной цели и цели
+# между собой на синтетических делах; векторы `pub` не несут, поэтому
+# здесь читается корпусный снимок, а не вектор.
+API_PACKAGES = ("codegen-api-strict", "codegen-api-aggregate")
+# Пакеты с поверхностью API над L1-планом (DECISION-0237 этап 5).
+API_PACKAGES_L1 = ("codegen-api-defeasible",)
+CLIR = ROOT / "corpus" / "clir"
+
+
+def version_probe(emit: dict) -> list[str]:
+    """Отрицательная проба: план чужой версии обязан быть отвергнут каждым
+    эмиттером. Без пробы проверка версии — договорённость, а не ворота."""
+    empty = {"package": {}, "tables": [], "rules": [], "facts": [], "consts": {}, "bases": {}}
+    failures = []
+    for lang, em in emit.items():
+        try:
+            em.emit(dict(empty, planVersion="law-backend-plan/999"))
+        except ValueError:
+            continue
+        failures.append(f"эмиттер {lang} принял план версии law-backend-plan/999")
+    for em in emit.values():
+        em.emit(dict(empty, planVersion=P.PLAN_VERSION))
+    # DECISION-0237: L1-план уходит только цели, объявившей его возможности;
+    # цель без объявления обязана отвергнуть и сам план, и поставку.
+    for version, cap in ((P.PLAN_VERSION_L1, "defeasible"), (P.PLAN_VERSION_09, "closure"),
+                         (P.PLAN_VERSION_10, "norm"), (P.PLAN_VERSION_11, "calendar:business")):
+        probe = dict(empty, planVersion=version, capabilities=[cap])
+        for lang, em in emit.items():
+            if D.missing_capabilities(probe, em):
+                try:
+                    em.emit(probe)
+                    failures.append(f"эмиттер {lang} без возможности {cap} принял план {version}")
+                except ValueError:
+                    pass
+    return failures
+
+
+def candidates():
+    """L0- и L1-векторы с промежуточным представлением, делом, запросом и голденом."""
+    for v in sorted(VECTORS.rglob("vector.json")):
+        meta = json.loads(v.read_text(encoding="utf-8"))
+        if meta.get("layer") not in LAYERS:
+            continue
+        d = v.parent
+        if not all((d / f).exists() for f in ("ir.json", "case.json", "query.json", "expected.json")):
+            continue
+        yield d, meta["layer"]
+
+
+def load(d: Path, name: str):
+    return json.loads((d / name).read_text(encoding="utf-8"))
+
+
+def golden_code(doc: dict) -> str | None:
+    """Код фатальной диагностики голдена без результата: `error.code` либо
+    первый fatal issue."""
+    if isinstance(doc.get("error"), dict):
+        return doc["error"].get("code")
+    return next((i.get("code") for i in doc.get("issues") or [] if i.get("severity") == "fatal"), None)
+
+
+def classify(d: Path, kinds: set, emit: dict, layer: str = "L0"):
+    """Исход до исполнения: отказ плана, вид запроса, голден. `None` — исполнять.
+
+    `kinds` — виды вопросов, которые исполняют ВСЕ активные цели (пересечение
+    `QUERY_KINDS` дескрипторов): вектор другого вида не исполняется, иначе
+    цель без поддержки отказала бы при ответе соседей, и это читалось бы
+    расхождением, а не границей среза. Так же с возможностями плана
+    (DECISION-0237): их обязаны объявить ВСЕ активные цели.
+
+    Возвращает (исход, план, ошибки ворот)."""
+    doc = load(d, "expected.json")
+    n = len(doc.get("results") or [])
+    code = golden_code(doc) if n == 0 else None
+    try:
+        ir = load(d, "ir.json")
+        # Мир вектора с импортом — его `producer.ir.json` (DECISION-0236);
+        # снимки корпуса векторам не нужны.
+        extra = [load(d, "producer.ir.json")] if (d / "producer.ir.json").exists() else []
+        world = P.resolve_world(ir, {}, extra) if ir.get("imports") else []
+        # Отрицательный факт дела требует модели с опорами обеих полярностей.
+        negative = any((a.get("literal") or {}).get("polarity") == "negative"
+                       for a in load(d, "case.json").get("assertions") or [])
+        # Байты снимка §85 у вектора — `calendar.resource.json` рядом (DECISION-0245).
+        resource = d / "calendar.resource.json"
+        resources = {n.get("resourceUri"): resource.read_bytes() for n in ir["nodes"]
+                     if n.get("kind") == "calendar_snapshot"} if resource.exists() else {}
+        pl = P.build_plan(ir, world, {"negation"} if negative else None, resources)
+    except P.Refused as exc:
+        head = str(exc).split(":")[0]
+        if layer == "L1" and n == 0:
+            if STRUCTURAL.get(code) == head:
+                return f"structural: {code}", None, []
+            # Иная СТРУКТУРНАЯ причина — подмена диагностики, ошибка ворот.
+            # Отказ по форме вне среза (терм, функция, тип) закреплён
+            # манифестом как отказ плана: срез не отвечает, а до проверки
+            # страт не доходит — форма, замыкающая цикл, сама вне среза
+            # (ERR-E0176-DEFEASIBLE-SELF-CYCLE: условный терм головы §56).
+            if head in STRUCTURAL.values():
+                return f"plan: {head}", None, [f"голден — структурный отказ {code}, план отказал иной причиной: {exc}"]
+            return f"plan: {head}", None, []
+        return f"plan: {head}", None, []
+    missing = sorted({c for em in emit.values() for c in D.missing_capabilities(pl, em)})
+    if missing:
+        return f"capability: {', '.join(missing)}", None, []
+    kind = load(d, "query.json").get("kind")
+    if kind not in kinds:
+        return f"query: {kind}", None, []
+    if n != 1:
+        errors = [f"голден — структурный отказ {code}, а план построен"] if layer == "L1" and n == 0 else []
+        return f"golden: результатов {n}", None, errors
+    return None, pl, []
+
+
+def crash_line(stderr: str) -> str:
+    """Строка stderr, называющая причину: у Go это первая `panic:`, у Node —
+    строка с `Error:`, у Python — последняя строка трассировки."""
+    lines = [line.strip() for line in stderr.splitlines() if line.strip()]
+    if not lines:
+        return "(stderr пуст)"
+    for line in lines:
+        if line.startswith("panic:") or "Error:" in line or "Error [" in line or "error:" in line:
+            return line[:200]
+    return lines[-1][:200]
+
+
+def sh(cmd, cwd=None) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, capture_output=True, text=True, cwd=cwd)
+
+
+def build_projects(emit: dict, projs: dict[str, list[Path]], work: Path) -> list[str]:
+    """Сборка всех проектов каждой цели; список отказов сборки."""
+    problems = []
+    for lang, dirs in projs.items():
+        em = emit[lang]
+        if not dirs:
+            continue
+        if hasattr(em, "build_many"):
+            for offset in range(0, len(dirs), 32):
+                batch = dirs[offset:offset + 32]
+                cmd, cwd = em.build_many([str(d) for d in batch], work / "out")
+                res = sh(cmd, cwd)
+                if res.returncode != 0:
+                    problems.append(f"сборка {lang} отказала\n{(res.stdout + res.stderr)[:2000]}")
+                    break
+            continue
+        if lang == "go" and len(dirs) > 1:
+            from concurrent.futures import ThreadPoolExecutor
+            def build_one(directory):
+                command, cwd = em.build(str(directory))
+                result = sh(command, cwd)
+                return (f"сборка {lang} отказала на {directory.relative_to(work)}\n"
+                        + (result.stdout + result.stderr)[:1200]) if result.returncode else None
+            # Go's cache supports concurrent writers; these are distinct projects.
+            with ThreadPoolExecutor(max_workers=4) as pool:
+                problems.extend(error for error in pool.map(build_one, dirs) if error)
+            continue
+        for d in dirs:
+            step = em.build(str(d))
+            if step is None:
+                continue
+            cmd, cwd = step
+            res = sh(cmd, cwd)
+            if res.returncode != 0:
+                problems.append(f"сборка {lang} отказала на {d.relative_to(work)}\n{(res.stdout + res.stderr)[:1200]}")
+    return problems
+
+
+def run_target(em, proj: Path, main: str, args: list[str]):
+    """Один запуск: ('answer', кортеж) | ('refused', текст) | ('crash', причина)."""
+    cmd, cwd = em.run(str(proj), main)
+    res = sh(cmd + args, cwd)
+    if res.returncode == 0:
+        try:
+            a = json.loads(res.stdout)
+            if main == "cert":
+                return "answer", a
+            return "answer", answer_key(a)
+        except (ValueError, KeyError, TypeError):
+            return "crash", f"код 0, но ответ не JSON ответа: {res.stdout[:200]!r}"
+    if res.returncode == REFUSED_EXIT:
+        try:
+            return "refused", json.loads(res.stdout)["refused"]
+        except (ValueError, KeyError, TypeError):
+            return "crash", f"код {REFUSED_EXIT} без JSON отказа: {res.stdout[:200]!r}"
+    return "crash", f"код {res.returncode}: {crash_line(res.stderr or res.stdout)}"
+
+
+def canon_value(value) -> str:
+    """Канонические байты §208 значения результата — оракульским каноном, а
+    не сериализатором цели: порядок элементов коллекции и запись чисел у
+    раннера проверяются против той же функции, что печатает голден."""
+    sys.path.insert(0, str(ROOT / "engines" / "lawref"))
+    from lawref.canon import canonical_bytes
+    return canonical_bytes(value, document=False).decode("utf-8")
+
+
+LAYERS = ("L0", "L1", "L2", "L3")
+
+
+def positions_key(status: str, positions: list, supports: list) -> str:
+    """Ответ `positions` без id и доказательства (DECISION-0242 K4): сводный
+    статус, мультимножество позиций (шаблон, модальность, держатель,
+    beneficiary, заземлённый payload, статус) и мультимножество опор статуса.
+    Держатель-заглушка `<позиция>/holder` зависит от счётчика позиций и
+    сравнивается как заглушка."""
+    def actor(v):
+        return "<fallback>" if str(v).startswith("urn:position:") else v
+
+    items = []
+    for p in positions:
+        item = {"template": p["template"], "modality": p["modality"], "holder": actor(p.get("holder")),
+                "status": p["status"], "payload": p["payload"]}
+        if "beneficiary" in p:
+            item["beneficiary"] = actor(p["beneficiary"])
+        items.append(canon_value(item))
+    sups = sorted(canon_value([s["status"], s["truthStatus"]]) for s in supports)
+    return "NORM_POSITION:" + status + ":" + canon_value(sorted(items)) + ":" + canon_value(sups)
+
+
+def answer_key(a: dict) -> tuple:
+    """Сравнимая тройка ответа: у truth — статус истинности, у term/collect —
+    канонические байты значения, у positions — позиции без id; далее статус
+    вычисления и issues."""
+    if "normativeStatus" in a:
+        head = positions_key(a["normativeStatus"], a["positions"], a["supports"])
+    elif "truthStatus" in a:
+        head = a["truthStatus"]
+    else:
+        # RUNTIME_ERROR вопроса `term` значения не несёт (DECISION-0252 п. 9) —
+        # как голден, а не `null`.
+        head = a["resultKind"] + ":" + (canon_value(a["value"]) if "value" in a else "")
+    return (head, a["evaluationStatus"], tuple(a.get("issues") or []), requests_key(a.get("judgmentRequests") or []))
+
+
+def requests_key(requests: list) -> str:
+    """DECISION-0274: запросы судье §47.3 сверяются с голденом целиком, кроме
+    proof-полей (`proof` — узел proof-графа, которого у среза нет): id,
+    отношение, орган, объект запроса, форма."""
+    return canon_value([{k: v for k, v in r.items() if k != "proof"} for r in requests])
+
+
+def golden_requests(doc: dict) -> str:
+    return requests_key((doc["results"][0] or {}).get("judgmentRequests") or [])
+
+
+def golden_key(doc: dict) -> tuple:
+    exp = doc["results"][0]
+    if exp.get("resultKind") == "NORM_POSITION":
+        return (positions_key(exp.get("normativeStatus"), doc.get("positions") or [],
+                              exp.get("normativeStatusSupports") or []), exp.get("evaluationStatus"))
+    if "truthStatus" in exp:
+        return (exp.get("truthStatus"), exp.get("evaluationStatus"))
+    head = exp.get("resultKind") + ":" + (canon_value(exp["value"]) if "value" in exp else "")
+    return (head, exp.get("evaluationStatus"))
+
+
+def certify(emit: dict, work: Path, active: list[str]) -> list[str]:
+    """Сертификация рантайма: фикстура `runtime-cert.json` исполняется каждой
+    целью, ответ каждого случая сверяется с ожиданием, записанным из контракта
+    README, а не снятым с реализации — сравнение целей между собой общую
+    ошибку не находит (коллизия ключа `["a|e:b","c"]` / `["a","b|e:c"]` жила
+    во всех трёх рантаймах одинаково)."""
+    fixture = json.loads(CERT.read_text(encoding="utf-8"))
+    expect = {c["id"]: c["expect"] for c in fixture["cases"]}
+    problems = []
+    projs = {}
+    for lang in active:
+        d = work / "cert" / lang
+        D.emit_project({}, lang, d, main="cert")
+        projs[lang] = [d]
+    problems += build_projects(emit, projs, work / "cert")
+    if problems:
+        return ["сертификация: " + p for p in problems]
+    for lang in active:
+        kind, payload = run_target(emit[lang], work / "cert" / lang, "cert", [str(CERT)])
+        if kind != "answer":
+            problems.append(f"сертификация {lang}: {kind.upper()}, {payload}")
+            continue
+        got = {row["id"]: row["got"] for row in payload}
+        for cid, want in expect.items():
+            if cid not in got:
+                problems.append(f"сертификация {lang}: случай {cid} не исполнен")
+            elif got[cid] != want:
+                problems.append(f"сертификация {lang}: {cid}: ожидалось {json.dumps(want, ensure_ascii=False)}, "
+                                f"получено {json.dumps(got[cid], ensure_ascii=False)}")
+    return problems
+
+
+def synth_arg(kind: str, i: int, param: str = ""):
+    """Синтетический литерал-терм §53 по виду столбца; enum — нет (члены плану неизвестны).
+    Тип значения — объявленный тип параметра: синтетика положительных заданий
+    канонична и по §189 принимается и раннером, и API."""
+    if kind == "text":
+        if param == "urn:law:std#Text":
+            return {"kind": "value", "type": {"name": param}, "value": f"apicheck-{i}"}
+        return {"kind": "entity_ref", "id": f"urn:apicheck:e{i}"}
+    if kind == "money":
+        return {"kind": "value", "type": {"name": "urn:law:std#Money"}, "value": str(100 + i), "currency": "KZT"}
+    if kind == "dec":
+        name = param if param in ("urn:law:std#Integer", "urn:law:std#Natural") else "urn:law:std#Decimal"
+        # §208 (errata E-0197): канон литерала `Integer` — целое JSON-ЧИСЛО, а
+        # `Decimal` — строка. До errata обе реализации и все три цели читали
+        # `"10"` в слоте Integer средствами своего языка; теперь это TYPE_ERROR
+        # у оракула, и синтетический аргумент ворот обязан быть каноничен.
+        if name != "urn:law:std#Decimal":
+            return {"kind": "value", "type": {"name": name}, "value": 10 + i}
+        return {"kind": "value", "type": {"name": name}, "value": str(10 + i)}
+    if kind == "date":
+        return {"kind": "value", "type": {"name": "urn:law:std#Date"}, "value": "2026-01-01"}
+    return None
+
+
+def wrong_arg(kind: str, param: str):
+    """Литерал заведомо чужого типа для слота (§189, DECISION-0423 §2.6):
+    Decimal в слоте сущности и Text, Decimal в Integer, Integer в Decimal,
+    Decimal в Money, Text в Date. Раннер и оракул не принимают такое
+    утверждение (`TYPE_ERROR`); API обязан ответить так же."""
+    dec = {"kind": "value", "type": {"name": "urn:law:std#Decimal"}, "value": "10.5"}
+    if kind == "text":
+        return dec
+    if kind == "dec":
+        if param in ("urn:law:std#Integer", "urn:law:std#Natural"):
+            return dec
+        return {"kind": "value", "type": {"name": "urn:law:std#Integer"}, "value": 10}
+    if kind == "money":
+        return dec
+    if kind == "date":
+        return {"kind": "value", "type": {"name": "urn:law:std#Text"}, "value": "2026-01-01"}
+    return None
+
+
+def _job(q: dict, facts: list, args: list, tag: str) -> dict:
+    return {"question": q["name"], "pred": q["pred"], "on": "2026-01-01", "args": args, "facts": facts, "tag": tag}
+
+
+def api_jobs(pl: dict) -> list:
+    """Задания проверки API (DECISION-0423 §2.6). Для каждого вопроса:
+    дело из одного факта на каждый его вход (одна и та же сущность во всех
+    аргументах, чтобы правила с соединением по переменной срабатывали);
+    у модели L1 — тот же вопрос с первым входом, поданным отрицательным
+    фактом; и отрицательный случай — первый аргумент первого факта подан
+    литералом чужого типа (§189)."""
+    jobs = []
+    inputs = {i["name"]: i for i in pl["api"]["inputs"]}
+    by_pred = {i["pred"]: i["name"] for i in pl["api"]["inputs"]}
+    for q in pl["api"]["questions"]:
+        args = [synth_arg(k, 0, t) for k, t in zip(q["kinds"], q["params"])]
+        facts = []
+        for pred in q["inputs"]:
+            i = inputs[by_pred[pred]]
+            fa = [synth_arg(k, 0, t) for k, t in zip(i["kinds"], i["params"])]
+            if any(a is None for a in fa):
+                facts = None
+                break
+            facts.append({"input": i["name"], "pred": pred, "args": fa})
+        if facts is None or any(a is None for a in args):
+            continue
+        jobs.append(_job(q, facts, args, "positive"))
+        # L1 (DECISION-0237): тот же вопрос с первым входом, поданным
+        # отрицательным фактом, — путь `negated_*` API и §113 раннера.
+        if facts and "negation" in (pl.get("capabilities") or ()):
+            neg = [dict(facts[0], polarity="negative")] + facts[1:]
+            jobs.append(_job(q, neg, args, "negated"))
+        if facts:
+            i = inputs[facts[0]["input"]]
+            bad = wrong_arg(i["kinds"][0], i["params"][0]) if i["params"] else None
+            if bad is not None:
+                wrong = [dict(facts[0], args=[bad] + facts[0]["args"][1:])] + facts[1:]
+                jobs.append(_job(q, wrong, args, "wrong-type"))
+    return jobs
+
+
+def key_conflict_plan(pl: dict):
+    """Синтетический ключ §45.1 на первом входе арности не меньше двух: план
+    с `keys = [[0]]` у его таблицы и имя входа. Дело с двумя фактами одного
+    первого аргумента даёт `KEY_CONFLICT`; вопрос, читающий вход, — у
+    раннера `NON_EXECUTABLE` (E-0242), независимый — `COMPUTED`. Норма общая
+    для любого пакета, поэтому ключ синтетический (DECISION-0423 §2.6)."""
+    for i in pl["api"]["inputs"]:
+        if len(i["params"]) < 2 or any(synth_arg(k, 1, t) is None for k, t in zip(i["kinds"], i["params"])):
+            continue
+        mutated = copy.deepcopy(pl)
+        for t in mutated["tables"]:
+            if t["pred"] == i["pred"]:
+                t["keys"] = [[0]]
+        return mutated, i
+    return None, None
+
+
+def key_conflict_jobs(pl: dict, keyed: dict) -> list:
+    jobs = []
+    for job in api_jobs(pl):
+        if job["tag"] != "positive":
+            continue
+        extra = {"input": keyed["name"], "pred": keyed["pred"],
+                 "args": [synth_arg(keyed["kinds"][0], 0, keyed["params"][0])]
+                 + [synth_arg(k, 1, t) for k, t in zip(keyed["kinds"][1:], keyed["params"][1:])]}
+        first = {"input": keyed["name"], "pred": keyed["pred"],
+                 "args": [synth_arg(k, 0, t) for k, t in zip(keyed["kinds"], keyed["params"])]}
+        facts = [f for f in job["facts"] if f["input"] != keyed["name"]] + [first, extra]
+        jobs.append(dict(job, facts=facts, tag="key-conflict"))
+    return jobs
+
+
+def _api_case_query(job: dict, j: int) -> tuple[dict, dict]:
+    case = {"context": {"legalTime": job["on"]},
+            "assertions": [{"literal": {"kind": "literal", "predicate": f["pred"],
+                                        "polarity": f.get("polarity", "positive"), "args": f["args"]}}
+                           for f in job["facts"]]}
+    query = {"kind": "truth", "queryId": job["queryId"],
+             "literal": {"kind": "literal", "predicate": job["pred"], "polarity": "positive", "args": job["args"]}}
+    return case, query
+
+
+def _api_emit(emit: dict, pl: dict, active: list[str], root: Path) -> tuple[dict, list[str]]:
+    projs, problems = {}, []
+    for lang in active:
+        proj = root / lang
+        D.emit_project(pl, lang, proj)
+        harness = BACKENDS / "targets" / lang / emit[lang].MAINS["apicheck"]
+        shutil.copyfile(harness, proj / harness.name)
+        projs[lang] = [proj]
+    problems += build_projects(emit, projs, root)
+    for lang in active:
+        if hasattr(emit[lang], "build_api"):
+            cmd, cwd = emit[lang].build_api(str(projs[lang][0]))
+            res = sh(cmd, cwd)
+            if res.returncode != 0:
+                problems.append(f"сборка харнесса {lang} отказала\n{(res.stdout + res.stderr)[:1200]}")
+    return projs, problems
+
+
+def _api_batch(em, proj: Path, path: Path) -> tuple[str, object]:
+    """Пакет заданий в одном процессе харнесса: ('answers', [исход…]) либо
+    ('crash', причина). Исход задания — ('answer', ключ) или ('refused', текст)."""
+    cmd, cwd = em.run(str(proj), "apicheck")
+    res = sh(cmd + [str(path)], cwd)
+    if res.returncode != 0:
+        return "crash", f"код {res.returncode}: {crash_line(res.stderr or res.stdout)}"
+    try:
+        out = json.loads(res.stdout)
+        return "answers", [("refused", a["refused"]) if "refused" in a else ("answer", answer_key(a))
+                           for a in out["answers"]]
+    except (ValueError, KeyError, TypeError):
+        return "crash", f"ответ пакета не JSON: {res.stdout[:200]!r}"
+
+
+def _api_run(emit: dict, projs: dict, active: list[str], jobs: list, root: Path, label: str,
+             problems: list) -> tuple[int, dict]:
+    """Каждое задание: раннер и API каждой цели дают один исход. Возвращает
+    число сверенных заданий и исходы раннера по номеру задания."""
+    checked, runner = 0, {}
+    for j, job in enumerate(jobs):
+        d = root / "jobs" / f"{j:03d}"
+        d.mkdir(parents=True, exist_ok=True)
+        job["queryId"] = f"urn:query:apicheck:{j}"
+        case, query = _api_case_query(job, j)
+        (d / "job.json").write_text(json.dumps(job, ensure_ascii=False), encoding="utf-8")
+        (d / "case.json").write_text(json.dumps(case, ensure_ascii=False), encoding="utf-8")
+        (d / "query.json").write_text(json.dumps(query, ensure_ascii=False), encoding="utf-8")
+        got = {}
+        for lang in active:
+            proj = projs[lang][0]
+            got[f"{lang}/runner"] = run_target(emit[lang], proj, "runner", [str(d / "case.json"), str(d / "query.json")])
+            got[f"{lang}/api"] = run_target(emit[lang], proj, "apicheck", [str(d / "job.json")])
+        crashes = [f"{k}: {msg}" for k, (kind, msg) in got.items() if kind == "crash"]
+        if crashes:
+            problems.append(f"api {label} {job['question']} ({job['tag']}): КРАХ {crashes}")
+            continue
+        if len(set(got.values())) != 1:
+            problems.append(f"api {label} {job['question']} ({job['tag']}): ответы разошлись {got}")
+            continue
+        runner[j] = got[f"{active[0]}/runner"]
+        checked += 1
+    return checked, runner
+
+
+def api_check(emit: dict, work: Path, active: list[str]) -> tuple[list[str], int]:
+    """API против раннера (DECISION-0234, DECISION-0423 §2.6): те же факты и
+    тот же вопрос дают один исход у API и раннера каждой цели и у всех целей
+    между собой — на положительных заданиях, отрицательных фактах L1,
+    литералах чужого типа (§189) и синтетическом конфликте ключа §45.1 при
+    читающем и независимом вопросе. Затем пакет всех заданий с повтором
+    первого исполняется одним процессом харнесса — последовательно и
+    параллельно (потоки Python, горутины Go): состояние между вызовами не
+    протекает. Канарейка: порча статуса и issues в общей части API Python
+    обязана дать расхождение."""
+    problems, checked = [], 0
+    for name in API_PACKAGES + API_PACKAGES_L1:
+        path = CLIR / f"{name}.lawir.json"
+        if not path.exists():
+            problems.append(f"api {name}: снимка {path.relative_to(ROOT)} нет")
+            continue
+        try:
+            ir = json.loads(path.read_text(encoding="utf-8"))
+            world = P.resolve_world(ir, P.world_index(ROOT)) if ir.get("imports") else []
+            pl = P.build_plan(ir, world)
+        except P.Refused as exc:
+            problems.append(f"api {name}: план отказал — {exc}")
+            continue
+        jobs = api_jobs(pl)
+        if not jobs:
+            problems.append(f"api {name}: ни одного вопроса с синтезируемыми входами")
+            continue
+        projs, build = _api_emit(emit, pl, active, work / "api" / name)
+        problems += [f"api {name}: {p}" for p in build]
+        if build:
+            return problems, checked
+        n, runner = _api_run(emit, projs, active, jobs, work / "api" / name, name, problems)
+        checked += n
+        # Пакет в одном процессе: A, B, …, A — повторный вызов не видит прежних фактов.
+        batch = jobs + jobs[:1]
+        expect = [runner.get(j) for j in range(len(jobs))] + [runner.get(0)]
+        for concurrent in (False, True):
+            bpath = work / "api" / name / f"batch-{'par' if concurrent else 'seq'}.json"
+            bpath.write_text(json.dumps({"batch": batch, "concurrent": concurrent}, ensure_ascii=False), encoding="utf-8")
+            for lang in active:
+                kind, outs = _api_batch(emit[lang], projs[lang][0], bpath)
+                if kind == "crash":
+                    problems.append(f"api {name}: пакет {lang} {'параллельно' if concurrent else 'последовательно'} — КРАХ {outs}")
+                    continue
+                for j, (want, have) in enumerate(zip(expect, outs)):
+                    if want is not None and want != have:
+                        problems.append(f"api {name}: пакет {lang} {'параллельно' if concurrent else 'последовательно'}, "
+                                        f"задание {j}: {have} против раннера {want}")
+                if len(outs) != len(expect):
+                    problems.append(f"api {name}: пакет {lang} ответил {len(outs)} исходами из {len(expect)}")
+        keyed_plan, keyed = key_conflict_plan(pl)
+        if keyed_plan is not None:
+            kjobs = key_conflict_jobs(keyed_plan, keyed)
+            kprojs, build = _api_emit(emit, keyed_plan, active, work / "api" / name / "key-conflict")
+            problems += [f"api {name} key-conflict: {p}" for p in build]
+            if not build and kjobs:
+                n, _ = _api_run(emit, kprojs, active, kjobs, work / "api" / name / "key-conflict",
+                                name + " key-conflict", problems)
+                checked += n
+        if "py" in active:
+            problems += _api_canary(emit, projs["py"][0], jobs, work / "api" / name / "canary", name)
+    return problems, checked
+
+
+def _api_canary(emit: dict, proj: Path, jobs: list, root: Path, name: str) -> list[str]:
+    """Канарейка API: копия проекта `py`, у которой общая часть API отвечает
+    `COMPUTED` без issues вместо ответа `evaluate`. На заданиях с литералом
+    чужого типа раннер даёт `TYPE_ERROR`, поэтому хоть одно расхождение
+    обязано найтись — иначе ворота не видят статуса и issues API."""
+    wrong = [j for j in jobs if j["tag"] == "wrong-type"]
+    if not wrong:
+        return []
+    if root.exists():
+        shutil.rmtree(root)
+    shutil.copytree(proj, root)
+    base = root / "api_base.py"
+    if not base.exists():
+        return [f"api {name}: канарейке нечего портить — в проекте py нет api_base.py"]
+    text = base.read_text(encoding="utf-8")
+    spoiled = text.replace('evaluation_status=doc["evaluationStatus"], issues=tuple(doc["issues"])',
+                           'evaluation_status="COMPUTED", issues=()')
+    if spoiled == text:
+        return [f"api {name}: канарейка не нашла, что портить в api_base.py"]
+    base.write_text(spoiled, encoding="utf-8")
+    for j, job in enumerate(wrong):
+        d = root / "jobs" / f"{j:03d}"
+        d.mkdir(parents=True, exist_ok=True)
+        job = dict(job, queryId=f"urn:query:apicheck:c{j}")
+        case, query = _api_case_query(job, j)
+        (d / "job.json").write_text(json.dumps(job, ensure_ascii=False), encoding="utf-8")
+        (d / "case.json").write_text(json.dumps(case, ensure_ascii=False), encoding="utf-8")
+        (d / "query.json").write_text(json.dumps(query, ensure_ascii=False), encoding="utf-8")
+        a = run_target(emit["py"], root, "apicheck", [str(d / "job.json")])
+        r = run_target(emit["py"], root, "runner", [str(d / "case.json"), str(d / "query.json")])
+        if a != r:
+            return []
+    return [f"api {name}: канарейка — порча статуса и issues в api_base.py не видна воротам"]
+
+
+def fixtures_check(emit: dict, work: Path, active: list[str]) -> tuple[list[str], list[str]]:
+    """Фикстуры поражаемого слоя (DECISION-0237): ответ из прозы на всех
+    целях, тот же ответ в перестановке правил и фактов, и канарейка —
+    программа без решающей нормы обязана дать ДРУГОЙ, тоже записанный из
+    прозы ответ, то есть ровно на своём случае провалить сверку с ожиданием.
+    Структурные фикстуры сверяют причину отказа плана."""
+    problems, report = [], []
+    jobs = []
+    for fx in FX.FIXTURES:
+        if "plan" not in fx and (fx["canary"]["expect"], sorted(fx["canary"].get("issues", fx.get("issues", [])))) \
+                == (fx["expect"], sorted(fx.get("issues", []))):
+            problems.append(f"фикстура {fx['name']}: ожидание канарейки совпадает с ожиданием — она не упадёт")
+        if "plan" in fx:
+            try:
+                P.build_plan(FX.program(fx), None, None, FX.resources(fx))
+                problems.append(f"фикстура {fx['name']}: план построен, ожидался отказ «{fx['plan']}»")
+            except P.Refused as exc:
+                if str(exc).split(":")[0] != fx["plan"]:
+                    problems.append(f"фикстура {fx['name']}: отказ «{exc}», ожидался «{fx['plan']}»")
+            continue
+        base = (fx["expect"], tuple(sorted(fx.get("issues", []))))
+        canary = (fx["canary"]["expect"], tuple(sorted(fx["canary"].get("issues", fx.get("issues", [])))))
+        drop = tuple(fx["canary"]["drop"])
+        variants = [("base", FX.program(fx), FX.case(fx), base, ()),
+                    ("perm", FX.program(fx, reverse=True), FX.case(fx, reverse=True), base, ()),
+                    ("canary", FX.program(fx, drop=drop), FX.case(fx, drop=drop), canary, drop)]
+        for tag, ir, kase, want, dropped in variants:
+            d = work / "fixtures" / f"{fx['name']}-{tag}"
+            try:
+                pl = P.build_plan(ir, None, None, FX.resources(fx, dropped))
+            except P.Refused as exc:
+                problems.append(f"фикстура {fx['name']} ({tag}): план отказал — {exc}")
+                continue
+            d.mkdir(parents=True, exist_ok=True)
+            (d / "case.json").write_text(json.dumps(kase, ensure_ascii=False), encoding="utf-8")
+            (d / "query.json").write_text(json.dumps(FX.query(fx), ensure_ascii=False), encoding="utf-8")
+            jobs.append((fx, tag, d, want))
+            for lang in active:
+                D.emit_project(pl, lang, d / lang)
+    if problems:
+        return problems, report
+    build = build_projects(emit, {lang: [d / lang for _fx, _t, d, _w in jobs] for lang in active}, work / "fixtures")
+    if build:
+        return [f"фикстуры: {b}" for b in build], report
+    for fx, tag, d, want in jobs:
+        args = [str(d / "case.json"), str(d / "query.json")]
+        got = {lang: run_target(emit[lang], d / lang, "runner", args) for lang in active}
+        bad = {lang: v for lang, v in got.items() if v[0] != "answer"}
+        if bad:
+            problems.append(f"фикстура {fx['name']} ({tag}): не ответ {bad}")
+            continue
+        # У ответа `positions` ключ начинается сводным статусом (DECISION-0242).
+        head = lambda k: k.split(":")[1] if k.startswith("NORM_POSITION:") else k
+        statuses = {lang: (head(v[1][0]), tuple(sorted(c for c in v[1][2] if c in BACKEND_ISSUES)))
+                    for lang, v in got.items()}
+        if len(set(statuses.values())) != 1:
+            problems.append(f"фикстура {fx['name']} ({tag}): цели разошлись {statuses}")
+            continue
+        status = next(iter(statuses.values()))
+        if status != want:
+            problems.append(f"фикстура {fx['name']} ({tag}): {status} против ожидания {want}")
+        elif tag == "canary":
+            # Канарейка упала ровно на своём случае: снятая норма меняет ответ.
+            shown = lambda st, codes: st + (f" {list(codes)}" if codes else " без issues")
+            report.append(f"канарейка {fx['name']}: без {', '.join(fx['canary']['drop'])} — "
+                          f"{shown(*status)}, сверка с ожиданием "
+                          f"{shown(fx['expect'], sorted(fx.get('issues', [])))} падает")
+    if not problems:
+        n = sum(1 for fx in FX.FIXTURES if "plan" not in fx)
+        report.insert(0, f"фикстуры L1 — {n} с ответом (и перестановкой), "
+                         f"{len(FX.FIXTURES) - n} структурных отказов, совпали на целях {', '.join(active)}")
+    return problems, report
+
+
+# DECISION-0252/0256: мутационные канарейки плана значений. Решающую норму
+# Rational и Quantity держат векторы `LAY-L0-RAT-*`/`LAY-L0-QTY-*`, но вектор
+# подтверждает только то, что модуль С нормой совпал; модуль, из плана которого
+# норма снята, обязан с голденом РАЗОЙТИСЬ — иначе норма воротам не видна.
+# Язык фикстур L1 деления и Rational не знает, поэтому канарейка — мутация
+# плана вектора, а не программы. Исполняется целью py (она всегда активна).
+VALUE_CANARIES = (
+    ("LAY-L0-RAT-DYN-DECIMAL-KEPT", "kindChecks", "сверка вида головы E-0077"),
+    ("LAY-L0-RAT-GUARD-DYN-MIX", "err", "ошибка значения гарда — issue"),
+    ("LAY-L0-RAT-HEAD-DIV-ZERO", "headFallible", "ошибка значения головы — issue"),
+    ("LAY-L0-RAT-DYN-RATIONAL-KEPT", "lk", "статический вид операнда"),
+    ("LAY-L0-QTY-GUARD-DIMENSION", "err", "разные единицы в гарде — issue"),
+    ("LAY-L0-QTY-ADD-DIMENSION", "headFallible", "разные единицы в голове — issue"),
+    # DECISION-0259 п. 10: политика округления §50 в плане 0.14.
+    ("LAY-L0-RND-DIVROUND-GUARD-ZERO", "err", "ошибка значения div_round в гарде — issue"),
+    ("LAY-L0-RND-DIVROUND-HEAD-ZERO", "headFallible", "ошибка значения div_round в голове — issue"),
+    ("LAY-L0-RND-GUARD-CEILING", "mode", "режим округления из литерала"),
+    ("LAY-L0-RND-DIVROUND-MONEY-RATIO", "precision", "точность политики: округление не пропущено"),
+    ("LAY-L0-RND-DIVROUND-MONEY-RATIO", "ak", "статический вид аргумента политики"),
+)
+
+
+def _mutate_value_plan(pl: dict, what: str) -> dict:
+    out = copy.deepcopy(pl)
+    for r in out.get("rules", []):
+        if what in ("kindChecks", "headFallible"):
+            r.pop(what, None)
+        elif what == "err":
+            for g in r.get("guards", []):
+                g.pop("err", None)
+    if what in ("mode", "precision", "ak"):
+        # DECISION-0259: режим — на HALF_UP, литеральная точность — на единицу
+        # меньше, вид делимого — Decimal вместо плана.
+        stack = [out]
+        while stack:
+            x = stack.pop()
+            if isinstance(x, dict):
+                if x.get("k") == "call" and "ak" in x:
+                    mode, prec = x["args"][-1], x["args"][-2]
+                    if what == "mode" and mode.get("k") == "lit":
+                        mode["v"] = "HALF_UP"
+                    elif what == "precision" and prec.get("k") == "lit" and int(prec["v"]) > 0:
+                        prec["v"] = str(int(prec["v"]) - 1)
+                    elif what == "ak":
+                        x["ak"][0] = "d" if x["ak"][0] != "d" else "m"
+                stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+            elif isinstance(x, list):
+                stack.extend(x)
+    if what == "lk":
+        stack = [out]
+        while stack:
+            x = stack.pop()
+            if isinstance(x, dict):
+                if x.get("k") == "bin" and x.get("op") == "div" and "lk" in x:
+                    x["lk"] = x["rk"] = "d"
+                stack.extend(v for v in x.values() if isinstance(v, (dict, list)))
+            elif isinstance(x, list):
+                stack.extend(x)
+    return out
+
+
+def value_canaries(emit: dict, work: Path) -> tuple[list[str], list[str]]:
+    """Канарейки VALUE_CANARIES: мутированный план обязан разойтись с голденом."""
+    problems, report, jobs = [], [], []
+    for vid, what, why in VALUE_CANARIES:
+        d = VECTORS / "lay" / vid
+        try:
+            pl = P.build_plan(load(d, "ir.json"))
+        except P.Refused as exc:
+            # DECISION-0372: архивный вектор 0.1 план не строит — канарейке
+            # нужен вектор поддерживаемой версии, а не обход отказа.
+            problems.append(f"канарейка {vid}: план отказал — {exc}")
+            continue
+        mutated = _mutate_value_plan(pl, what)
+        if mutated == pl:
+            problems.append(f"канарейка {vid}: мутация «{what}» план не меняет — нормы в плане нет")
+            continue
+        # Одна программа может нести несколько канареек: проект — на пару (вектор, мутация).
+        proj = work / "value-canaries" / f"{vid}-{what}"
+        D.emit_project(mutated, "py", proj)
+        jobs.append((vid, what, why, d, proj))
+    if problems:
+        return problems, report
+    build = build_projects(emit, {"py": [j[4] for j in jobs]}, work / "value-canaries")
+    if build:
+        return [f"канарейки значений: {b}" for b in build], report
+    for vid, what, why, d, proj in jobs:
+        doc = load(d, "expected.json")
+        want = golden_key(doc)
+        want_issues = sorted(i["code"] for i in doc.get("issues") or [] if i.get("code") in BACKEND_ISSUES)
+        kind, payload = run_target(emit["py"], proj, "runner",
+                                   [str(d.resolve() / "case.json"), str(d.resolve() / "query.json")])
+        if kind == "crash":
+            problems.append(f"канарейка {vid}: без «{what}» — крах {payload}")
+        elif kind == "answer" and payload[:2] == want \
+                and sorted(c for c in payload[2] if c in BACKEND_ISSUES) == want_issues:
+            problems.append(f"канарейка {vid}: без «{what}» ответ совпал с голденом — норма «{why}» воротам не видна")
+        else:
+            shown = payload[:2] if kind == "answer" else f"отказ «{payload}»"
+            report.append(f"канарейка {vid}: без «{what}» ({why}) — {shown}, сверка с голденом падает")
+    return problems, report
+
+
+# Политика пустой коллекции §59 (errata E-0195). Векторы `ERR-E0195-EMPTY-POLICY-*`
+# несут в comprehension СВЯЗКУ, и раннер отказывает до агрегата — норма о сверке
+# вида политики с видом элемента им не проверяется ни у одной цели. Пробы ниже
+# берут тот же пакет и то же дело вектора, но comprehension без связок: путь
+# агрегата раннера достижим. Ожидания записаны ИЗ errata («вид политики обязан
+# совпасть с видом элемента ПУСТОЙ коллекции; у оракула несовпадение —
+# TYPE_ERROR»), а не сняты с реализации; первая проба — свидетель нормы (без
+# сверки цели отвечают `Integer 0` и `COMPUTED`, то есть ДРУГИМ ответом, а не
+# меньшим), две остальные держат её от переусердствования: совпавший вид и
+# непустая коллекция обязаны отвечать как прежде.
+EMPTY_POLICY_VECTOR = "errata/ERR-E0195-EMPTY-POLICY-KIND-RUNTIME"
+_EP_MONEY = {"kind": "value", "type": {"name": "urn:law:std#Money"}, "value": "0", "currency": "KZT"}
+_EP_INTEGER = {"kind": "value", "type": {"name": "urn:law:std#Integer"}, "value": 0}
+_EP_SUM = {"kind": "value", "type": {"name": "urn:law:std#Money"}, "value": "80", "currency": "KZT"}
+EMPTY_POLICY_PROBES = (
+    ("несовпадение вида над пустой коллекцией", "absent", _EP_INTEGER, None, "TYPE_ERROR", ("TYPE_ERROR",)),
+    ("совпадение вида над пустой коллекцией", "absent", _EP_MONEY, _EP_MONEY, "COMPUTED", ()),
+    ("несовпадение вида над НЕпустой коллекцией", "order_amount", _EP_INTEGER, _EP_SUM, "COMPUTED", ()),
+)
+
+
+def empty_policy_probes(emit: dict, work: Path, active: list[str]) -> tuple[list[str], list[str]]:
+    """Сверка вида empty-политики §59 в раннере каждой цели (errata E-0195)."""
+    d = VECTORS / EMPTY_POLICY_VECTOR
+    if not d.exists():
+        return [f"проба политики §59: вектора {EMPTY_POLICY_VECTOR} нет"], []
+    problems, report = [], []
+    try:
+        pl = P.build_plan(load(d, "ir.json"))
+    except P.Refused as exc:
+        return [f"проба политики §59: план вектора {EMPTY_POLICY_VECTOR} отказал — {exc}"], report
+    base = work / "empty-policy"
+    for lang in active:
+        D.emit_project(pl, lang, base / lang)
+    build = build_projects(emit, {lang: [base / lang] for lang in active}, base)
+    if build:
+        return [f"проба политики §59: {b}" for b in build], report
+    template = load(d, "query.json")
+    for n, (why, pred, policy, value, status, issues) in enumerate(EMPTY_POLICY_PROBES):
+        q = copy.deepcopy(template)
+        q["term"]["input"].pop("binders", None)
+        q["term"]["input"]["generator"]["formula"]["predicate"] = f"urn:law:vectors:err-e0195#{pred}"
+        q["term"]["options"] = {"empty": policy}
+        job = base / f"q{n}"
+        job.mkdir(parents=True, exist_ok=True)
+        (job / "query.json").write_text(json.dumps(q, ensure_ascii=False), encoding="utf-8")
+        want = ("DATA:" + (canon_value(value) if value is not None else ""), status, tuple(issues))
+        got = {}
+        for lang in active:
+            kind, payload = run_target(emit[lang], base / lang, "runner",
+                                       [str(d.resolve() / "case.json"), str(job / "query.json")])
+            got[lang] = (kind, payload[:3] if kind == "answer" else payload)
+        bad = {lang: v for lang, v in got.items() if v[0] != "answer"}
+        if bad:
+            problems.append(f"проба политики §59 ({why}): не ответ {bad}")
+            continue
+        answers = {lang: v[1] for lang, v in got.items()}
+        if len(set(answers.values())) != 1:
+            problems.append(f"проба политики §59 ({why}): цели разошлись {answers}")
+            continue
+        answer = next(iter(answers.values()))
+        if answer != want:
+            problems.append(f"проба политики §59 ({why}): {answer} против ожидания {want}")
+    if not problems:
+        report.append(f"политика пустой коллекции §59 (E-0195) — {len(EMPTY_POLICY_PROBES)} пробы "
+                      f"совпали с нормой на целях {', '.join(active)}")
+    return problems, report
+
+
+# Граница JSON-числа канона §208 (errata E-0202). Вектор
+# `ERR-E0202-CANON-NUMBER-I64-MAX` держит ОДНУ сторону границы — целое i64
+# читается точно; вторая сторона воротам недостижима: у float и у целого вне
+# i64 голден есть error-объект §172 без результата, и `classify` такой вектор
+# не исполняет. Между тем ровно там ts терял знаки (`JSON.parse` сводит число
+# к double), и без пробы норма держалась бы на слове. Ожидания записаны ИЗ
+# errata: целое знакового 64-битного диапазона законно, всё прочее — отказ
+# одним текстом у всех целей, потому что канала error-объекта у профиля
+# `core-executable` нет.
+CANON_NUMBER_VECTOR = "errata/ERR-E0202-CANON-NUMBER-I64-MAX"
+CANON_NUMBER_REFUSAL = ("JSON-число вне канона §208 (только целое знакового 64-битного "
+                        "диапазона) вне среза раннера")
+CANON_NUMBER_PROBES = (
+    ("i64 max читается точно", 2 ** 63 - 1, str(2 ** 63 - 1)),
+    ("i64 min читается точно", -(2 ** 63), str(-(2 ** 63))),
+    ("целое над i64 — отказ", 2 ** 63, None),
+    ("целое под i64 — отказ", -(2 ** 63) - 1, None),
+    ("JSON-float — отказ", 1.5, None),
+)
+
+
+def canon_number_probes(emit: dict, work: Path, active: list[str]) -> tuple[list[str], list[str]]:
+    """Граница i64 §208 в раннере каждой цели (errata E-0202)."""
+    d = VECTORS / CANON_NUMBER_VECTOR
+    if not d.exists():
+        return [f"проба числа канона §208: вектора {CANON_NUMBER_VECTOR} нет"], []
+    problems, report = [], []
+    try:
+        pl = P.build_plan(load(d, "ir.json"))
+    except P.Refused as exc:
+        return [f"проба числа канона §208: план вектора {CANON_NUMBER_VECTOR} отказал — {exc}"], report
+    base = work / "canon-number"
+    for lang in active:
+        D.emit_project(pl, lang, base / lang)
+    build = build_projects(emit, {lang: [base / lang] for lang in active}, base)
+    if build:
+        return [f"проба числа канона §208: {b}" for b in build], report
+    template = load(d, "query.json")
+    for n, (why, value, want_digits) in enumerate(CANON_NUMBER_PROBES):
+        q = copy.deepcopy(template)
+        q["term"]["value"] = value
+        job = base / f"q{n}"
+        job.mkdir(parents=True, exist_ok=True)
+        job.joinpath("query.json").write_text(json.dumps(q, ensure_ascii=False), encoding="utf-8")
+        got = {}
+        for lang in active:
+            kind, payload = run_target(emit[lang], base / lang, "runner",
+                                       [str(d.resolve() / "case.json"), str(job / "query.json")])
+            got[lang] = (kind, payload[:2] if kind == "answer" else payload)
+        crashes = {lang: v for lang, v in got.items() if v[0] == "crash"}
+        if crashes:
+            problems.append(f"проба числа канона §208 ({why}): КРАХ {crashes}")
+            continue
+        if len({v for v in got.values()}) != 1:
+            problems.append(f"проба числа канона §208 ({why}): цели разошлись {got}")
+            continue
+        kind, payload = next(iter(got.values()))
+        if want_digits is None:
+            if kind != "refused" or payload != CANON_NUMBER_REFUSAL:
+                problems.append(f"проба числа канона §208 ({why}): ожидался отказ "
+                                f"«{CANON_NUMBER_REFUSAL}», получено {kind} {payload}")
+        else:
+            want = ('DATA:{"kind":"value","type":{"name":"urn:law:std#Integer"},'
+                    f'"value":{want_digits}}}', "COMPUTED")
+            if kind != "answer" or tuple(payload) != want:
+                problems.append(f"проба числа канона §208 ({why}): {kind} {payload} против {want}")
+    if not problems:
+        report.append(f"граница i64 §208 (E-0202) — {len(CANON_NUMBER_PROBES)} пробы совпали "
+                      f"с нормой на целях {', '.join(active)}")
+    return problems, report
+
+
+def execute(emit: dict, d: Path, work: Path, active: list[str]):
+    """Исход исполнения вектора всеми целями и список ошибок ворот по нему."""
+    doc = load(d, "expected.json")
+    want = golden_key(doc)
+    want_issues = sorted(i["code"] for i in doc.get("issues") or [] if i.get("code") in BACKEND_ISSUES)
+    args = [str(d.resolve() / "case.json"), str(d.resolve() / "query.json")]
+    got = {lang: run_target(emit[lang], work / d.name / lang, "runner", args) for lang in active}
+    crashes = [f"КРАХ {lang}: {msg}" for lang, (k, msg) in got.items() if k == "crash"]
+    if crashes:
+        return "crash", crashes
+    refused = {lang: msg for lang, (k, msg) in got.items() if k == "refused"}
+    if refused and len(refused) != len(got):
+        answered = {lang: v for lang, (k, v) in got.items() if k == "answer"}
+        return "divergence", [f"отказ не единогласен: отказали {sorted(refused)}, ответили {answered}"]
+    if refused:
+        if len(set(refused.values())) != 1:
+            return "divergence", [f"тексты отказа различаются: {refused}"]
+        return f"runtime: {next(iter(refused.values()))}", []
+    answers = {lang: v for lang, (_k, v) in got.items()}
+    if len(set(answers.values())) != 1:
+        return "divergence", [f"РАСХОЖДЕНИЕ между бэкендами: {answers}"]
+    answer = next(iter(answers.values()))
+    if answer[:2] != want:
+        return "divergence", [f"расхождение с голденом: {answer[:2]} против {want}"]
+    got_issues = sorted(c for c in answer[2] if c in BACKEND_ISSUES)
+    if got_issues != want_issues:
+        return "divergence", [f"расхождение issues с голденом: {got_issues} против {want_issues}"]
+    if answer[3] != golden_requests(doc):
+        # DECISION-0274: судьи §47.3 — часть ответа, сверяются кроме proof-полей.
+        return "divergence", [f"расхождение judgmentRequests с голденом: {answer[3]} против {golden_requests(doc)}"]
+    return "match", []
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--keep", metavar="DIR", help="сохранить порождённые проекты")
+    ap.add_argument("--targets", default=DEFAULT_TARGETS, metavar="ЦЕЛИ",
+                    help=f"цели через запятую либо all (по умолчанию {DEFAULT_TARGETS})")
+    ap.add_argument("--require", default="", metavar="ЦЕЛИ",
+                    help="цели через запятую, отсутствие тулчейна которых — отказ ворот")
+    ap.add_argument("--manifest", type=Path, default=MANIFEST)
+    ap.add_argument("--write-manifest", action="store_true",
+                    help="закрепить исходы всех L0- и L1-векторов (только при отсутствии крахов и расхождений)")
+    args = ap.parse_args()
+
+    known = D.targets(protocol="runner")
+    wanted = known if args.targets == "all" else [x for x in args.targets.split(",") if x]
+    unknown = [x for x in wanted if x not in known]
+    if unknown:
+        print(f"check_backends: неизвестные цели: {', '.join(unknown)} (есть: {', '.join(known)})")
+        return 1
+    emit = {lang: D.emitter(lang) for lang in known}
+    failures = version_probe(emit)
+    if failures:
+        for line in failures:
+            print("check_backends: " + line)
+        return 1
+    l1_targets = sorted(lang for lang, em in emit.items() if not D.missing_capabilities(
+        {"capabilities": ["defeasible", "negation", "priority"]}, em))
+    v09_targets = sorted(lang for lang, em in emit.items() if not D.missing_capabilities(
+        {"capabilities": ["aggregate", "closure"]}, em))
+    v10_targets = sorted(lang for lang, em in emit.items() if not D.missing_capabilities(
+        {"capabilities": ["norm"]}, em))
+    v11_targets = sorted(lang for lang, em in emit.items() if not D.missing_capabilities(
+        {"capabilities": sorted(P.CAL_CAPS)}, em))
+    print(f"check_backends: план {P.PLAN_VERSION}; проба чужой версии отвергнута всеми эмиттерами ({len(emit)}); "
+          f"план {P.PLAN_VERSION_L1} печатают {', '.join(l1_targets)}, {P.PLAN_VERSION_09} — "
+          f"{', '.join(v09_targets)}, {P.PLAN_VERSION_10} — {', '.join(v10_targets)}, "
+          f"{P.PLAN_VERSION_11} — {', '.join(v11_targets)}, остальные отвергают")
+
+    tools = {lang: emit[lang].available() for lang in wanted}
+    active = [lang for lang in wanted if tools[lang][0]]
+    if "py" not in active:
+        print("check_backends: цель py обязательна всегда")
+        return 1
+    print("check_backends: цели —", ", ".join(f"{k} ({tools[k][1]})" for k in active))
+    for lang in wanted:
+        if not tools[lang][0]:
+            print(f"check_backends: цель {lang} ПРОПУЩЕНА — {tools[lang][1]}")
+    required = [x for x in args.require.split(",") if x]
+    missing = [x for x in required if x not in active]
+    if missing:
+        print(f"check_backends: обязательные цели без тулчейна: {', '.join(missing)}")
+        return 1
+    emit = {lang: emit[lang] for lang in active}
+
+    kinds = set.intersection(*[set(getattr(emit[lang], "QUERY_KINDS", {"truth"})) for lang in active])
+    print(f"check_backends: виды вопросов у всех активных целей — {', '.join(sorted(kinds))}")
+    outcomes: dict[str, str] = {}
+    layers: dict[str, str] = {}
+    accepted = []
+    problems: list[str] = []
+    for d, layer in candidates():
+        layers[d.name] = layer
+        outcome, pl, errors = classify(d, kinds, emit, layer)
+        problems += [f"{d.name}: {e}" for e in errors]
+        if outcome is None:
+            accepted.append((d, pl))
+        else:
+            outcomes[d.name] = outcome
+    by_layer = collections.Counter(layers.values())
+    print(f"check_backends: векторов L0 рассмотрено {by_layer['L0']}, L1 — {by_layer['L1']}; "
+          f"план построен и запрос поддержан у {len(accepted)}")
+
+    work = Path(args.keep) if args.keep else Path(tempfile.mkdtemp(prefix="law-backends-"))
+    work.mkdir(parents=True, exist_ok=True)
+
+    cert_problems = certify(emit, work, active)
+    if cert_problems:
+        for line in cert_problems:
+            print("  " + line)
+        print("check_backends: сертификация рантайма НЕ пройдена")
+        return 1
+    n_cases = len(json.loads(CERT.read_text(encoding="utf-8"))["cases"])
+    print(f"check_backends: сертификация рантайма — {n_cases} случаев на целях {', '.join(active)}")
+
+    api_problems, api_checked = api_check(emit, work, active)
+    if api_problems:
+        for line in api_problems:
+            print("  " + line)
+        print("check_backends: проверка API НЕ пройдена")
+        return 1
+    print(f"check_backends: API — {api_checked} вопросов на {len(API_PACKAGES) + len(API_PACKAGES_L1)} пакетах совпали с раннером на целях {', '.join(active)}")
+
+    fx_problems, fx_report = fixtures_check(emit, work, active)
+    for line in fx_report:
+        print("check_backends: " + line)
+    if fx_problems:
+        for line in fx_problems:
+            print("  " + line)
+        print("check_backends: фикстуры поражаемого слоя НЕ пройдены")
+        return 1
+
+    vc_problems, vc_report = value_canaries(emit, work)
+    for line in vc_report:
+        print("check_backends: " + line)
+    if vc_problems:
+        for line in vc_problems:
+            print("  " + line)
+        print("check_backends: канарейки значений (DECISION-0252/0256) НЕ пройдены")
+        return 1
+
+    ep_problems, ep_report = empty_policy_probes(emit, work, active)
+    for line in ep_report:
+        print("check_backends: " + line)
+    if ep_problems:
+        for line in ep_problems:
+            print("  " + line)
+        print("check_backends: пробы политики пустой коллекции §59 (errata E-0195) НЕ пройдены")
+        return 1
+
+    cn_problems, cn_report = canon_number_probes(emit, work, active)
+    for line in cn_report:
+        print("check_backends: " + line)
+    if cn_problems:
+        for line in cn_problems:
+            print("  " + line)
+        print("check_backends: пробы границы JSON-числа канона §208 (errata E-0202) НЕ пройдены")
+        return 1
+
+    # Проекты печатает та же поставка, что отдаёт модуль потребителю
+    # (`deliver.emit_project`): ворота проверяют ровно то, что уезжает.
+    projs = {lang: [] for lang in active}
+    for d, pl in accepted:
+        for lang in active:
+            proj = work / d.name / lang
+            D.emit_project(pl, lang, proj)
+            projs[lang].append(proj)
+    build_problems = build_projects(emit, projs, work)
+    if build_problems:
+        for line in build_problems:
+            print("check_backends: " + line)
+        return 1
+
+    for d, _ in accepted:
+        outcome, errors = execute(emit, d, work, active)
+        outcomes[d.name] = outcome
+        problems += [f"{d.name}: {e}" for e in errors]
+    if not args.keep:
+        shutil.rmtree(work, ignore_errors=True)
+
+    for layer in LAYERS:
+        stat = collections.Counter(o.split(":")[0] for name, o in outcomes.items() if layers[name] == layer)
+        if stat:
+            print(f"check_backends: {layer} — " + ", ".join(f"{key}: {n}" for key, n in sorted(stat.items())))
+    matched_l2 = sum(1 for name, o in outcomes.items() if layers[name] in ("L2", "L3") and o == "match")
+    matched = sum(1 for name, o in outcomes.items() if layers[name] == "L0" and o == "match")
+    matched_l1 = sum(1 for name, o in outcomes.items() if layers[name] == "L1"
+                     and (o == "match" or o.startswith("structural:")))
+
+    if problems:
+        for line in problems:
+            print("  " + line)
+        return 1
+
+    if args.write_manifest:
+        args.manifest.write_text(json.dumps(
+            {"format": MANIFEST_FORMAT, "targets": active, "vectors": dict(sorted(outcomes.items()))},
+            ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+        print(f"check_backends: манифест записан — {len(outcomes)} векторов, {matched} совпадений L0, "
+              f"{matched_l1} L1, {matched_l2} L2/L3")
+        return 0
+
+    if not args.manifest.exists():
+        print(f"check_backends: манифеста нет — {args.manifest} (--write-manifest)")
+        return 1
+    pinned = json.loads(args.manifest.read_text(encoding="utf-8"))
+    if pinned.get("format") != MANIFEST_FORMAT:
+        print(f"check_backends: формат манифеста не {MANIFEST_FORMAT}")
+        return 1
+    registry: dict[str, str] = pinned["vectors"]
+    for name, expected in sorted(registry.items()):
+        actual = outcomes.get(name)
+        if actual is None:
+            problems.append(f"{name}: закреплён как «{expected}», вектора нет")
+        elif actual != expected:
+            problems.append(f"{name}: закреплено «{expected}», получено «{actual}»")
+    unpinned = sorted(n for n in outcomes if n not in registry)
+    for name in unpinned:
+        if outcomes[name] == "match" or outcomes[name].startswith("structural:"):
+            problems.append(f"{name}: совпал (или структурный отказ), но не закреплён в манифесте (--write-manifest)")
+    if unpinned:
+        print(f"check_backends: незакреплённых векторов {len(unpinned)} "
+              f"(без совпадений: {sum(1 for n in unpinned if outcomes[n] != 'match')})")
+    if problems:
+        for line in problems:
+            print("  " + line)
+        return 1
+    if matched < MIN_CHECKED:
+        print(f"check_backends: исполнено {matched} векторов при поле храповика {MIN_CHECKED}")
+        return 1
+    if matched_l1 < MIN_CHECKED_L1:
+        print(f"check_backends: L1 — {matched_l1} совпадений при поле храповика {MIN_CHECKED_L1}")
+        return 1
+    if matched_l2 < MIN_CHECKED_L2:
+        print(f"check_backends: L2/L3 — {matched_l2} совпадений при поле храповика {MIN_CHECKED_L2}")
+        return 1
+    print(f"check_backends: OK — L0 {matched} векторов совпали, L1 {matched_l1} (совпадения и "
+          f"структурные отказы), L2/L3 {matched_l2} на целях {', '.join(active)}; манифест {len(registry)} исходов повторён")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())